PowerShell.sublime-syntax

%YAML 1.2
---
# http://www.sublimetext.com/docs/3/syntax.html
name: PowerShell
scope: source.powershell
version: 2

file_extensions:
  - ps1
  - psm1
  - psd1

first_line_match: |-
  (?x:
    ^\#!.*\b(?:pwsh|powershell)\b
  | ^\# \s* -\*- [^*]* mode: \s* powershell [^*]* -\*-
  )

variables:
  dec_exponent: (?:[eE][-+]?\d*)
  dec_suffix: '[dD]'
  float_suffix: '[dDlL]'
  int_suffix: (?i:u[lsy]?|[lnsy])
  unit_suffix: (?i:[kmgtp]b\b)
  kebab_break: (?![\w-])

contexts:

  pop-before-newline:
    - match: (?=\n|$)
      pop: true

  pop-at-newline:
    - match: \n|$
      pop: true

  main:
    - include: regions
    - include: comments
    - include: expressions

  expressions:
    - include: redirection
    - include: commands
    - include: variable
    - include: group
    - include: function
    - include: attribute
    - include: using-directive
    - include: type
    - include: hashtable
    - include: strings
    - include: script-block
    - include: escape-characters
    - include: numeric-constant
    - include: class-method
    - match: (@)(\()
      captures:
        1: keyword.other.array.begin.powershell
        2: punctuation.section.group.begin.powershell
      push:
        - meta_scope: meta.group.array-expression.powershell
        - match: \)
          scope: punctuation.section.group.end.powershell
          pop: true
        - include: main
    - match: (\$)(\()
      # TODO: move to repo; make recursive.
      captures:
        1: keyword.other.variable.definition.powershell
        2: punctuation.section.group.begin.powershell
      push:
        - meta_scope: meta.group.complex.subexpression.powershell
        - match: \)
          scope: punctuation.section.group.end.powershell
          pop: true
        - include: main
    - match: \b[\w.-]+\.(?i:exe|com|cmd|bat)\b
      scope: variable.function.powershell
    # Consume a string with a trailing dot
    # to prevent members with particular names from being recognized as keywords.
    - match: \b[\w-]+(?=\.)
      scope: variable.other.object.powershell
      push: members
    # Exceptions
    - match: \b(?i:throw){{kebab_break}}
      scope: keyword.control.exception.raise.powershell
    - match: \b(?i:try){{kebab_break}}
      scope: keyword.control.exception.try.powershell
    - match: \b(?i:catch|trap){{kebab_break}}
      scope: keyword.control.exception.catch.powershell
    - match: \b(?i:finally){{kebab_break}}
      scope: keyword.control.exception.finally.powershell
    # Conditionals
    - match: \b(?i:if){{kebab_break}}
      scope: keyword.control.conditional.if.powershell
    - match: \b(?i:elseif){{kebab_break}}
      scope: keyword.control.conditional.elseif.powershell
    - match: \b(?i:else){{kebab_break}}
      scope: keyword.control.conditional.else.powershell
    - match: \b(?i:switch){{kebab_break}}
      scope: keyword.control.conditional.switch.powershell
    - match: \?
      scope: keyword.control.conditional.select.powershell
    - match: \b(?i:where(?!-object)){{kebab_break}}
      scope: keyword.control.conditional.select.powershell
    # Begin/End
    - match: \b(?i:begin){{kebab_break}}
      scope: keyword.context.block.begin.powershell
    - match: \b(?i:process){{kebab_break}}
      scope: keyword.context.block.process.powershell
    - match: \b(?i:end){{kebab_break}}
      scope: keyword.context.block.end.powershell
    - match: \b(?i:clean){{kebab_break}}
      scope: keyword.context.block.clean.powershell
    # Loops
    - match: \b(?i:for|foreach(?!-object)){{kebab_break}}
      scope: keyword.control.loop.for.powershell
    - match: \b(?i:do){{kebab_break}}
      scope: keyword.control.loop.do-while.powershell
    - match: \b(?i:while){{kebab_break}}
      scope: keyword.control.loop.while.powershell
    - match: \b(?i:until){{kebab_break}}
      scope: keyword.control.loop.repeat-until.powershell
    # Flow
    - match: \b(?i:break){{kebab_break}}
      scope: keyword.control.flow.break.powershell
    - match: \b(?i:continue){{kebab_break}}
      scope: keyword.control.flow.continue.powershell
    - match: \b(?i:exit){{kebab_break}}
      scope: keyword.control.flow.exit.powershell
    - match: \b(?i:return){{kebab_break}}
      scope: keyword.control.flow.return.powershell
    # Declaration
    - match: \b(?i:var){{kebab_break}}
      # scope: storage.type.variable.powershell
      scope: keyword.declaration.variable.powershell
    - match: \b(?i:(?:dynamic)?param){{kebab_break}}
      scope: keyword.declaration.parameter.powershell  # This scope is not standard
    # Uncategorized keywords
    - match: \b(?i:data|default|define|from|in|inlinescript|parallel|sequence){{kebab_break}}
      scope: keyword.control.powershell
    - match: \B--%\B
      scope: keyword.control.powershell
      push:
        - meta_content_scope: string.unquoted.powershell
        - include: pop-before-newline
    - match: \b(?i:hidden|static)\b
      # This should only be relevant inside a class but will require a rework of how classes are matched. This is a temp fix.
      scope: storage.modifier.powershell
    - match: \b((?i:class))\s+([\w-]+)\b
      captures:
        1: storage.type.class.powershell
        2: meta.class.powershell entity.name.class.powershell
    # Operators...
    - match: \B(-)(?i:as){{kebab_break}}
      scope: keyword.operator.cast.powershell
      captures:
        1: punctuation.definition.keyword.powershell
    - match: \B(-)(?i:[ic]?(?:eq|ne|[gl][te])){{kebab_break}}
      scope: keyword.operator.comparison.powershell
      captures:
        1: punctuation.definition.keyword.powershell
    - match: \B(-)(?i:[ic]?(?:not)?(?:like|match|contains|in)){{kebab_break}}
      scope: keyword.operator.logical.powershell
      captures:
        1: punctuation.definition.keyword.powershell
    - match: \B(-)(?i:join|split|replace){{kebab_break}}
      scope: keyword.operator.string.powershell
      captures:
        1: punctuation.definition.keyword.powershell
    - match: \B(-)(?i:is(?:not)?){{kebab_break}}
      scope: keyword.operator.logical.powershell
      captures:
        1: punctuation.definition.keyword.powershell
    - match: \B(-)(?i:and|or|not|xor){{kebab_break}}|!   # <-- note `!`
      scope: keyword.operator.logical.powershell
      captures:
        1: punctuation.definition.keyword.powershell
    - match: \B(-)(?i:band|bor|bnot|bxor|sh[lr]){{kebab_break}}
      scope: keyword.operator.bitwise.powershell
      captures:
        1: punctuation.definition.keyword.powershell
    - match: \B(-)(?i:f){{kebab_break}}
      scope: keyword.operator.string-format.powershell
      captures:
        1: punctuation.definition.keyword.powershell
    # Flags/Options/Parameters
    - match: \B(--?|[/+])\p{L}(?:[\w-]*\w)?
      scope: variable.parameter.option.powershell
      captures:
        1: punctuation.definition.parameter.powershell
    # Operators continue...
    - match: '[+/*%-]?='
      scope: keyword.operator.assignment.powershell
    - match: (?:\+\+|--)(?![ \t]*\d)
      scope: keyword.operator.assignment.powershell
    - match: '[+-](?=\.?\d)'  # This is sort of heuristic
      scope: keyword.operator.unary.powershell
    - match: '[+/*-]'
      scope: keyword.operator.arithmetic.powershell
    - match: '%(?!\s*\{)'
      scope: keyword.operator.arithmetic.powershell
    - match: \|\||&&
      scope: keyword.operator.logical.powershell
    - match: \|
      scope: keyword.operator.logical.pipe.powershell
    - match: ;
      scope: punctuation.terminator.statement.powershell
    - match: \`(?=\n|$)
      scope: punctuation.separator.continuation.line.powershell
    - match: ','
      scope: punctuation.separator.sequence.powershell
    - match: '&|\B\.(?= )'
      scope: keyword.operator.other.powershell
    - match: \.\.(?=\-?\d|\(|\$)
      # This is very imprecise. Is there a syntax for 'must come after...'?
      scope: keyword.operator.range.powershell

  comments:
    - include: comment-block
    - include: comment-line

  redirection:
    # https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_redirection
    - match: ([2-6*])(>&)(1)
      captures:
        1: constant.numeric.decimal.file-descriptor.powershell
        2: keyword.operator.redirection.powershell
        3: constant.numeric.decimal.file-descriptor.powershell
    - match: ([1-6*])(>>?)
      captures:
        1: constant.numeric.decimal.file-descriptor.powershell
        2: keyword.operator.redirection.powershell
    - match: '>>?'
      scope: keyword.operator.redirection.powershell
    # - match: <+
    #   scope: invalid.illegal.powershell

  requires-directive:
    # TODO: add back `(?<=#)`-equivalent match
    - match: (#)((?i:requires))\s
      captures:
        1: punctuation.definition.keyword.powershell
        2: keyword.control.import.require.powershell
      push:
        - meta_scope: meta.requires.powershell
        - include: pop-at-newline
        - include: hashtable
        - match: (-)(?i:Modules|PSSnapin|RunAsAdministrator|ShellId|Version)
          scope: variable.parameter.option.powershell
          captures:
            1: punctuation.definition.variable.powershell
        - match: ','
          scope: punctuation.separator.powershell

  using-directive:
    - match: \b(?i:(using))\s+(?i:(namespace|module))\s+(?i:((?:\w+(?:\.)?)+))
      captures:
        1: keyword.control.using.powershell
        2: keyword.other.powershell
        3: variable.parameter.powershell

  attribute:
    - match: |-
        (?xi:
          (\[)\s*
          (
            CmdletBinding | Alias | OutputType | Parameter
          | Validate
            (?:
              Count | NotNull(?:OrEmpty)? | Range | Pattern | Length | Set
            | Script)
          | Allow(?: Null | Empty(?: Collection | String ))
          )\b
        )
      captures:
        1: punctuation.section.brackets.begin.powershell
        2: support.function.attribute.powershell
      push:
        - meta_scope: meta.attribute.powershell
        - match: \]
          scope: punctuation.section.brackets.end.powershell
          pop: true
        - match: \(
          scope: punctuation.section.group.begin.powershell
          push:
            - match: \)
              scope: punctuation.section.group.end.powershell
              pop: true
            - include: variable
            - include: variable-no-property
            - include: hashtable
            - include: script-block
            - include: escape-characters
            - include: double-quoted-string
            - include: type
            - include: numeric-constant
            - include: main
            - match: |-
                (?xi:
                  \b(
                    Mandatory | ValueFromPipeline(?:ByPropertyName)?
                  | ValueFromRemainingArguments | Position(?:alBinding)?
                  | (?:Default)?ParameterSetName | SupportsShouldProcess | SupportsPaging
                  | HelpUri | ConfirmImpact | HelpMessage
                  )\b
                  \s*(=)?
                )
              captures:
                1: variable.parameter.attribute.powershell
                2: keyword.operator.assignment.powershell
            - match: \'
              scope: punctuation.definition.string.begin.powershell
              push:
                - meta_scope: string.quoted.single.powershell
                - match: \'\'
                  scope: constant.character.escape.powershell
                - match: \'
                  scope: punctuation.definition.string.end.powershell
                  pop: true

  commands:
    # "Verb-Noun pattern:"
    - match: |-
        (?x:
          (?:[\w\\:-]*\\)?                                                     # Path stuff
          \b(?i:
            Add | Approve | Assert | Backup | Block | Build | Checkpoint       # "Official" Verbs
          | Clear | Close | Compare | Complete | Compress | Confirm | Connect
          | Convert | ConvertFrom | ConvertTo | Copy | Debug | Deny | Deploy
          | Disable | Disconnect | Dismount | Edit | Enable | Enter | Exit
          | Expand | Export | Find | Format | Get | Grant | Group | Hide
          | Import | Initialize | Install | Invoke | Join | Limit | Lock
          | Measure | Merge | Mount | Move | New | Open | Optimize | Out | Ping
          | Pop | Protect | Publish | Push | Read | Receive | Redo | Register
          | Remove | Rename | Repair | Request | Reset | Resize | Resolve
          | Restart | Restore | Resume | Revoke | Save | Search | Select | Send
          | Set | Show | Skip | Split | Start | Step | Stop | Submit | Suspend
          | Switch | Sync | Test | Trace | Unblock | Undo | Uninstall | Unlock
          | Unprotect | Unpublish | Unregister | Update | Use | Wait | Watch
          | Write
          )
          \-\w+?                                                               # Any "noun"
          (?:\.(?i:exe|cmd|bat|ps1))?\b                                        # More path stuff
        )
      scope: meta.function-call.powershell support.function.powershell
    # Builtin cmdlets with reserved verbs
    - match: \b(?i:(?:foreach|where|sort|tee)-object)\b
      scope: support.function.powershell

  comment-block:
    - match: <#
      scope: punctuation.definition.comment.block.begin.powershell
      push:
        - meta_scope: comment.block.powershell
        - match: '#>'
          scope: punctuation.definition.comment.block.end.powershell
          pop: true
        - include: comment-embedded-docs

  comment-embedded-docs:
    # TODO
    # https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_comment_based_help
    - match: |-
        (?xi:
          ^\s*(\.)
          (
            Component | Description | Example | ExternalHelp | ForwardHelpCategory | ForwardHelpTargetName
          | Functionality | Inputs | Link | Notes | Outputs | Parameter | RemoteHelpRunSpace
          | Role | Synopsis
          )
        )
      scope: comment.documentation.embedded.powershell
      captures:
        1: punctuation.definition.keyword.documentation.powershell
        2: keyword.other.documentation.powershell
    - match: ^\s*(\.)(?i:(Parameter)\s+([a-z0-9-_]+))
      scope: comment.documentation.embedded.powershell
      captures:
        1: punctuation.definition.keyword.documentation.powershell
        2: keyword.other.documentation.param.powershell
        3: variable.parameter.powershell
    - match: ^\s*(\.)(?i:(ForwardHelpTargetName|ForwardHelpCategory|ExternalHelp|Link)\s+([a-z0-9-_]+))
      scope: comment.documentation.embedded.powershell
      captures:
        1: punctuation.definition.keyword.documentation.powershell
        2: keyword.other.documentation.powershell
        3: markup.underline.link.powershell

  comment-line:
    - include: requires-directive
    - match: '#'
      scope: punctuation.definition.comment.powershell
      push:
        - meta_scope: comment.line.powershell
        - include: pop-at-newline
        - include: comment-embedded-docs

  static-members:
    # - meta_content_scope: debug.in.static-members
    - match: '::'
      scope: punctuation.accessor.double-colon.powershell
      set: members

  members:
    # - meta_content_scope: debug.in.members
    - match: (?=\.\.)
      pop: true
    - match: \.(?=\w)
      scope: punctuation.accessor.dot.powershell
    - match: (\w+)(\()
      captures:
        1: meta.function-call.powershell variable.function.powershell
        2: meta.function-call.arguments.powershell punctuation.section.arguments.begin.powershell
      push:
        - meta_content_scope: meta.function-call.arguments.powershell
        - match: \)
          scope: meta.function-call.arguments.powershell punctuation.section.arguments.end.powershell
          pop: true
        - include: expressions
    - match: \w+
      scope: variable.other.member.powershell
    - match: \[
      scope: punctuation.section.brackets.begin.powershell
      push:
        - meta_scope: meta.brackets.indexer.powershell
        - match: \]
          scope: punctuation.section.brackets.end.powershell
          pop: true
        - include: expressions
    - match: ''
      pop: true

  strings:
    - include: double-quoted-string
    - include: single-quoted-string
    - match: \@"(?=$)
      scope: punctuation.definition.string.begin.powershell
      push:
        - meta_scope: meta.string.powershell string.quoted.double.heredoc.powershell
        - match: ^"@
          scope: punctuation.definition.string.end.powershell
          pop: true
        - include: escape-characters
        - include: interpolation
    - match: \@'(?=$)
      scope: punctuation.definition.string.begin.powershell
      push:
        - meta_scope: meta.string.powershell string.quoted.single.heredoc.powershell
        - match: ^'@
          scope: punctuation.definition.string.end.powershell
          pop: true
        - match: "''"
          scope: constant.character.escape.powershell

  single-quoted-string:
    - match: \'
      scope: punctuation.definition.string.begin.powershell
      push:
        - meta_scope: meta.string.powershell string.quoted.single.powershell
        - match: "''"
          scope: constant.character.escape.powershell
        - match: \'
          scope: punctuation.definition.string.end.powershell
          pop: true

  double-quoted-string:
    - match: '"'
      scope: punctuation.definition.string.begin.powershell
      push:
        - meta_scope: meta.string.powershell string.quoted.double.powershell
        - match: '""'
          scope: constant.character.escape.powershell
        - include: escape-characters
        - match: '"'
          scope: punctuation.definition.string.end.powershell
          pop: true
        - match: '(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,64}\b'
        - include: interpolation
        - match: '`\s*$'
          scope: keyword.other.powershell

  escape-characters:
    - match: '`[0abenfrvt"''$`]'
      scope: constant.character.escape.powershell
    - match: '`u\{\h+\}'
      scope: constant.character.escape.powershell

  function:
    - match: ^(?:\s*)(?i)(function|filter|configuration|workflow)\s+(?:(global|local|script|private):)?((?:\p{L}|\d|_|-|\.)+)
      scope: meta.function.powershell
      captures:
        1: storage.type.powershell
        2: storage.modifier.scope.powershell
        3: entity.name.function.powershell
      push:
        - match: (?=\{|\()
          pop: true
        - include: comment-line

  hashtable:
    - match: (@)(\{)
      captures:
        1: keyword.other.hashtable.begin.powershell
        2: punctuation.section.braces.begin.powershell
      push:
        - meta_scope: meta.hashtable.powershell
        - match: \}
          scope: punctuation.section.braces.end.powershell
          pop: true
        - match: \b(['"]?)(\w+)(['"]?)\s*(=)\s*
          scope: meta.hashtable.assignment.powershell
          captures:
            1: punctuation.definition.string.begin.powershell
            2: variable.other.readwrite.powershell
            3: punctuation.definition.string.end.powershell
            4: keyword.operator.assignment.powershell
        - include: script-block
        - include: main

  group:
    - match: \(
      scope: punctuation.section.group.begin.powershell
      push:
        - meta_scope: meta.group.powershell
        - match: \)
          scope: punctuation.section.group.end.powershell
          pop: true
        - include: main

  interpolation:
    - match: \$\(
      scope: punctuation.section.interpolation.begin.powershell
      push:
        - clear_scopes: 1
        - meta_scope: meta.interpolation.powershell
        - meta_content_scope: source.powershell.embedded
        - match: \)
          scope: punctuation.section.interpolation.end.powershell
          pop: true
        - include: main
    - match: (?=\$)
      push:
        - clear_scopes: 1
        - meta_scope: meta.interpolation.powershell
        - include: variable-no-property
        - include: variable
        - match: ''
          pop: true

  numeric-constant:
    - match: \b(0[bB])([01]*)({{int_suffix}}?{{unit_suffix}}?)
      scope: meta.number.integer.binary.powershell
      captures:
        1: constant.numeric.base.powershell
        2: constant.numeric.value.powershell
        3: constant.numeric.suffix.powershell
      push: members
    - match: \b(0[xX])(\h*)({{int_suffix}}?{{unit_suffix}}?)
      scope: meta.number.integer.hexadecimal.powershell
      captures:
        1: constant.numeric.base.powershell
        2: constant.numeric.value.powershell
        3: constant.numeric.suffix.powershell
      push: members
    - match: |-
        (?x)
        (
        # .10 .10e5
         (\.)\d+{{dec_exponent}}?
        # 1.2 1.2e-3 1.e2 1e2
        | \d+ (?: (\.) \d+ {{dec_exponent}}? | (\.)? {{dec_exponent}} )
        )
        ( {{float_suffix}}? {{unit_suffix}}? )
        |
        # 10.l 10.lGB 10.GB
        ( \d+ (\.) )
        ( {{float_suffix}} {{unit_suffix}}? | {{unit_suffix}} )
      scope: meta.number.float.decimal.powershell
      captures:
        1: constant.numeric.value.powershell
        2: punctuation.separator.decimal.powershell
        3: punctuation.separator.decimal.powershell
        4: punctuation.separator.decimal.powershell
        5: constant.numeric.suffix.powershell
        6: constant.numeric.value.powershell
        7: punctuation.separator.decimal.powershell
        8: constant.numeric.suffix.powershell
      push: members
    - match: \b(\d+)({{dec_suffix}}{{unit_suffix}}?)
      scope: meta.number.float.decimal.powershell
      captures:
        1: constant.numeric.value.powershell
        2: constant.numeric.suffix.powershell
      push: members
    - match: \b(\d+)({{int_suffix}}?{{unit_suffix}}?)
      scope: meta.number.integer.decimal.powershell
      captures:
        1: constant.numeric.value.powershell
        2: constant.numeric.suffix.powershell
      push: members

  script-block:
    - match: (%)?(\{)
      captures:
        1: keyword.control.loop.for.powershell
        2: punctuation.section.braces.begin.powershell
      push:
        - meta_scope: meta.block.powershell
        - match: \}
          scope: punctuation.section.braces.end.powershell
          pop: true
        - include: main

  type:
    # TODO: push a maybe-static-members context
    - match: \[
      scope: punctuation.section.brackets.begin.powershell
      push:
        - match: \](?=::)
          scope: punctuation.section.brackets.end.powershell
          set: static-members
        - match: \]
          scope: punctuation.section.brackets.end.powershell
          pop: true
        - match: (?!\d+|\.)[\p{L}\p{N}.]+
          scope: storage.type.powershell
        - include: main

  variable:
    - match: (\$)(?i:True|False|Null)\b
      scope: constant.language.powershell
      captures:
        1: punctuation.definition.variable.powershell
    - match: |-
        (?xi:
          (\$)
          (?:
            ExecutionContext | Host | Home | IsCoreCLR | IsLinux | IsWindows
          | IsMacOS | PID | Profile | PsCommandPath | PsHome | PsScriptRoot
          | PsUiCulture | PsVersionTable | ShellID
          )
        )
      scope: support.constant.variable.powershell
      captures:
        1: punctuation.definition.variable.powershell
      push: members
    - match: |-
        (?xi:
          (\$)
          (?:
            [$^?_]
          | (?:
              Args | ConsoleFileName | Error | Event | EventArgs
            | EventSubscriber | ForEach | Input | LastExitCode | Matches
            | MyInvocation | NestedPromptLevel | PsBoundParameters | PsCmdlet
            | PsCulture | PsDebugContext | PsItem | Pwd | Sender | SourceArgs
            | SourceEventArgs | StackTrace | Switch | This
            )\b
          )
        )
      scope: variable.language.powershell
      captures:
        1: punctuation.definition.variable.powershell
      push: members
    - match: |-
        (?xi:
          (\$)
          (?:
            (?:
              Confirm | Debug | ErrorAction | Information | Progress | Verbose # *Preference
            | Warning | WhatIf
            )
            Preference
          | Maximum(?:Alias|Drive|Error|Function|History|Variable)Count        # Maximum*Count
          | Log(?:Command|Engine|Provider)(?:Health|Lifecycle)Event            # Log*Event
          | PsDebugContext | PsDefaultParameterValues | PsEmailServer
          | PsModuleAutoloadingPreference | PsSenderInfo
          | PsSessionApplicationName | PsSessionConfigurationName
          | PsSessionOption | ErrorView | FormatEnumerationLimit | OFS
          | OutputEncoding
          )
        )
      scope: variable.language.powershell
      captures:
        1: punctuation.definition.variable.powershell
      push: members
    - match: ((\$|@)(?i:(global|local|private|script|using|workflow):\w+))
      captures:
        1: variable.other.readwrite.powershell
        2: punctuation.definition.variable.powershell
        3: storage.modifier.scope.powershell
      push: members
    - match: ((\$)(\{)((?i:global|local|private|script|using|workflow)):([^}]*[^}`])(\}))
      captures:
        1: variable.other.readwrite.powershell
        2: punctuation.definition.variable.powershell
        3: punctuation.section.braces.begin.powershell
        4: storage.modifier.scope.powershell
        6: punctuation.section.braces.end.powershell
      push: members
    - match: ((?i:(\$|@)(\w+:)?\w+))
      captures:
        1: variable.other.readwrite.powershell
        2: punctuation.definition.variable.powershell
        3: support.variable.drive.powershell
        4: variable.other.member.powershell
      push: members
    - match: ((?i:(\$)(\{)(\w+:)?([^}]*[^}`])(\})))
      captures:
        1: variable.other.readwrite.powershell
        2: punctuation.definition.variable.powershell
        3: punctuation.section.braces.begin.powershell
        4: support.variable.drive.powershell
        6: punctuation.section.braces.end.powershell
      push: members

  variable-no-property:
    - match: (\$)(?i:True|False|Null)\b
      scope: constant.language.powershell
      captures:
        1: punctuation.definition.variable.powershell
    - match: |-
        (?xi:
          (\$)
          (?:
            ExecutionContext | Host | Home | IsCoreCLR | IsLinux | IsWindows
          | IsMacOS | PID | Profile | PsCommandPath | PsHome | PsScriptRoot
          | PsUiCulture | PsVersionTable | ShellID
          )
        )
      scope: support.constant.variable.powershell
      captures:
        1: punctuation.definition.variable.powershell
    - match: |-
        (?xi:
          (\$)
          (?:
            [$^?_]
          | (?:
              Args | ConsoleFileName | Error | Event | EventArgs
            | EventSubscriber | ForEach | Input | LastExitCode | Matches
            | MyInvocation | NestedPromptLevel | PsBoundParameters | PsCmdlet
            | PsCulture | PsDebugContext | PsItem | Pwd | Sender | SourceArgs
            | SourceEventArgs | StackTrace | Switch | This
            )\b
          )
        )
      scope: variable.language.powershell
      captures:
        1: punctuation.definition.variable.powershell
    - match: |-
        (?xi:
          (\$)
          (?:
            (?:
              Confirm | Debug | ErrorAction | Information | Progress | Verbose # *Preference
            | Warning | WhatIf
            )
            Preference
          | Maximum(?:Alias|Drive|Error|Function|History|Variable)Count        # Maximum*Count
          | Log(?:Command|Engine|Provider)(?:Health|Lifecycle)Event            # Log*Event
          | PsDebugContext | PsDefaultParameterValues | PsEmailServer
          | PsModuleAutoloadingPreference | PsSenderInfo
          | PsSessionApplicationName | PsSessionConfigurationName
          | PsSessionOption | ErrorView | FormatEnumerationLimit | OFS
          | OutputEncoding
          )
        )
      scope: variable.language.powershell
      captures:
        1: punctuation.definition.variable.powershell
    - match: (?i:(\$|@)(global|local|private|script|using|workflow):(\w+))
      captures:
        1: punctuation.definition.variable.powershell
        2: storage.modifier.scope.powershell
        3: variable.other.readwrite.powershell
    - match: (?i:(\$)(\{)(global|local|private|script|using|workflow):([^}]*[^}`])(\}))
      captures:
        1: punctuation.definition.variable.powershell
        2: punctuation.section.braces.begin
        3: storage.modifier.scope.powershell
        4: variable.other.readwrite.powershell
        5: punctuation.section.braces.end
    - match: (?i:(\$)(\w+:)?\w+)
      scope: variable.other.readwrite.powershell
      captures:
        1: punctuation.definition.variable.powershell
        2: support.variable.drive.powershell
    - match: (?i:(\$)(\{)(\w+:)?([^}]*[^}`])(\}))
      captures:
        1: punctuation.definition.variable.powershell
        2: punctuation.section.braces.begin
        3: support.variable.drive.powershell
        4: variable.other.readwrite.powershell
        5: punctuation.section.braces.end

  class-method:
    - match: ^(?:\s*)(?i)(hidden|static)?\s*(\[)((?!\d+|\.)[\p{L}\p{N}.]+)(\])\s*((?:\p{L}|\d|_|-|\.)+)\s*(?=\()
      scope: meta.function.powershell
      captures:
        1: storage.modifier.powershell
        2: punctuation.section.brackets.begin.powershell
        3: storage.type.powershell
        4: punctuation.section.brackets.end.powershell
        5: entity.name.function.powershell
      push:
        - match: (?=\()
          pop: true
        - include: comment-line

  regions:
    - match: ^\s*((#)\s*(region\b)(?:\s*(\S.*))?(\n?))
      captures:
        1: comment.line.powershell
        2: punctuation.definition.comment.powershell
        3: keyword.other.region.begin.powershell
        4: meta.toc-list.powershell entity.name.section.powershell
        5: meta.fold.begin.powershell
    - match: ^\s*((#)\s*(endregion\b).*(\n?))
      captures:
        1: comment.line.powershell
        2: punctuation.definition.comment.powershell
        3: keyword.other.region.end.powershell
        4: meta.fold.end.powershell