Bump version to v0.24.0

We need to bump 0.x.0 because the library API changed in incompatible ways: $ cargo public-api diff Resolved `diff` to `diff 0.23.0` Removed items from the public API ================================= (none) Changed items in the public API =============================== -pub fn bat::controller::Controller<'b>::run(&self, inputs: alloc::vec::Vec<bat::input::Input<'_>>) -> bat::error::Result<bool> +pub fn bat::controller::Controller<'b>::run(&self, inputs: alloc::vec::Vec<bat::input::Input<'_>>, output_buffer: core::option::Option<&mut dyn core::fmt::Write>) -> bat::error::Result<bool> -pub fn bat::controller::Controller<'b>::run_with_error_handler(&self, inputs: alloc::vec::Vec<bat::input::Input<'_>>, handle_error: impl core::ops::function::Fn(&bat::error::Error, &mut dyn std::io::Write)) -> bat::error::Result<bool> +pub fn bat::controller::Controller<'b>::run_with_error_handler(&self, inputs: alloc::vec::Vec<bat::input::Input<'_>>, output_buffer: core::option::Option<&mut dyn core::fmt::Write>, handle_error: impl core::ops::function::Fn(&bat::error::Error, &mut dyn std::io::Write)) -> bat::error::Result<bool> Added items to the public API ============================= [...]
Update CHANGELOG.md for v0.24.0
2026-08-03 18:51:44 +00:00 · 2023-10-11 19:14:12 +02:00 · 2023-10-10 16:50:20 +02:00 · 2023-10-10 06:16:41 +02:00 · 2023-10-06 09:14:08 +02:00 · 2023-10-06 09:11:06 +02:00
568 changed files with 44278 additions and 5248 deletions
@@ -0,0 +1 @@
 github: [sharkdp, keith-hall, Enselic]
@@ -8,32 +8,57 @@ assignees: ''
 ---
 <!--
 Hey there, thanks for creating an issue!
-In order to reproduce your issue, we might need to know a little bit more about the environment
+Hey there, thank you for reporting a bug!
 which you're running `bat` on.
-If you're on Linux or MacOS:
+Please note that the following bugs have already been reported:
-  Please run the script at https://github.com/sharkdp/bat/blob/master/diagnostics/info.sh and
+
-  paste the output at the bottom of the bug report.
+* dpkg: error processing archive /some/path/some-program.deb (--unpack):
  trying to overwrite '/usr/.crates2.json'
  See https://github.com/sharkdp/bat/issues/938
 If you're on Windows:
  Please tell us about your Windows Version (e.g. "Windows 10 1908") at the
  bottom of the bug report.
 -->
-**What version of `bat` are you using?**
+**What steps will reproduce the bug?**
-[paste the output of `bat --version` here]
+
 1. step 1
 2. step 2
 3. ...
 **What happens?**
 **Describe the bug you encountered:**
 ...
 **What did you expect to happen instead?**
 ...
 **How did you install `bat`?**
 <!-- apt-get, homebrew, GitHub release, etc. -->
 ---
-[paste the output of `info.sh` here]
+**bat version and environment**
 <!--
 In order to reproduce your issue, please add some information about the environment
 in which you're running bat. To do this, run the full `bat` command that demonstrates
 the bug, and attach the `--diagnostic` option:
    bat [other options and arguments…] --diagnostic
 Finally, paste the Markdown output here. Please make sure that it does not reveal any
 personal information.
 If you are running bat 0.17.1 or older (where --diagnostic is not available), please
 run the script at
    https://github.com/sharkdp/bat/blob/master/diagnostics/info.sh
 (click "Raw" to get the actual source code) and paste the Markdown output here. If you
 are on Windows, please let us know your bat version and your Windows version.
 -->
@@ -1,2 +1 @@
 blank_issues_enabled: true
@@ -7,4 +7,3 @@ assignees: ''
 ---
@@ -7,4 +7,5 @@ assignees: ''
 ---
-
+<!-- Using a normal ticket is still fine, but feel free to ask your
 questions about bat on https://github.com/sharkdp/bat/discussions instead. -->
@@ -0,0 +1,24 @@
 version: 2
 updates:
 - package-ecosystem: cargo
  directory: "/"
  schedule:
    interval: monthly
    time: "04:00"
    timezone: Europe/Berlin
  ignore:
  - dependency-name: git2
    versions:
    - 0.13.17
 - package-ecosystem: gitsubmodule
  directory: "/"
  schedule:
    interval: monthly
    time: "04:00"
    timezone: Europe/Berlin
 - package-ecosystem: "github-actions"
  directory: "/"
  schedule:
    interval: monthly
    time: "04:00"
    timezone: Europe/Berlin
@@ -1,220 +1,210 @@
 name: CICD
 env:
-  PROJECT_NAME: bat
+  CICD_INTERMEDIATES_DIR: "_cicd-intermediates"
-  PROJECT_DESC: "A `cat` clone with wings"
+  MSRV_FEATURES: --no-default-features --features minimal-application,bugreport,build-assets
  PROJECT_MAINTAINER: "David Peter <mail@david-peter.de>"
  PROJECT_HOMEPAGE: "https://github.com/sharkdp/bat"
  MIN_SUPPORTED_RUST_VERSION: "1.40.0"
-on: [push, pull_request]
+on:
  workflow_dispatch:
  pull_request:
  push:
    branches:
      - master
    tags:
      - '*'
 jobs:
  all-jobs:
    if: always() # Otherwise this job is skipped if the matrix job fails
    name: all-jobs
    runs-on: ubuntu-latest
    needs:
      - crate_metadata
      - ensure_cargo_fmt
      - min_version
      - license_checks
      - test_with_new_syntaxes_and_themes
      - test_with_system_config
      - documentation
      - cargo-audit
      - build
    steps:
      - run: jq --exit-status 'all(.result == "success")' <<< '${{ toJson(needs) }}'
  crate_metadata:
    name: Extract crate metadata
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Extract crate information
      id: crate_metadata
      run: |
        cargo metadata --no-deps --format-version 1 | jq -r '"name=" + .packages[0].name' | tee -a $GITHUB_OUTPUT
        cargo metadata --no-deps --format-version 1 | jq -r '"version=" + .packages[0].version' | tee -a $GITHUB_OUTPUT
        cargo metadata --no-deps --format-version 1 | jq -r '"maintainer=" + .packages[0].authors[0]' | tee -a $GITHUB_OUTPUT
        cargo metadata --no-deps --format-version 1 | jq -r '"homepage=" + .packages[0].homepage' | tee -a $GITHUB_OUTPUT
        cargo metadata --no-deps --format-version 1 | jq -r '"msrv=" + .packages[0].rust_version' | tee -a $GITHUB_OUTPUT
    outputs:
      name: ${{ steps.crate_metadata.outputs.name }}
      version: ${{ steps.crate_metadata.outputs.version }}
      maintainer: ${{ steps.crate_metadata.outputs.maintainer }}
      homepage: ${{ steps.crate_metadata.outputs.homepage }}
      msrv: ${{ steps.crate_metadata.outputs.msrv }}
  ensure_cargo_fmt:
    name: Ensure 'cargo fmt' has been run
    runs-on: ubuntu-20.04
    steps:
    - uses: dtolnay/rust-toolchain@stable
      with:
        components: rustfmt
    - uses: actions/checkout@v4
    - run: cargo fmt -- --check
  min_version:
    name: Minimum supported rust version
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    needs: crate_metadata
    steps:
-    - name: Git checkout
+    - name: Checkout source code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
-    - name: Install rust toolchain (v${{ env.MIN_SUPPORTED_RUST_VERSION }})
+
-      uses: actions-rs/toolchain@v1
+    - name: Install rust toolchain (v${{ needs.crate_metadata.outputs.msrv }})
      uses: dtolnay/rust-toolchain@master
      with:
-        toolchain: ${{ env.MIN_SUPPORTED_RUST_VERSION }}
+        toolchain: ${{ needs.crate_metadata.outputs.msrv }}
-        default: true
+        components: clippy
-        profile: minimal # minimal component installation (ie, no documentation)
+    - name: Run clippy (on minimum supported rust version to prevent warnings we can't fix)
-    - name: Test
+      run: cargo clippy --locked --all-targets ${{ env.MSRV_FEATURES }}
-      uses: actions-rs/cargo@v1
+    - name: Run tests
      run: cargo test --locked ${{ env.MSRV_FEATURES }}
  license_checks:
    name: License checks
    runs-on: ubuntu-20.04
    steps:
    - uses: actions/checkout@v4
      with:
-        command: test
+        submodules: true # we especially want to perform license checks on submodules
    - run: tests/scripts/license-checks.sh
  test_with_new_syntaxes_and_themes:
-    name: Test with new syntaxes and themes
+    name: Run tests with updated syntaxes and themes
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    steps:
    - name: Git checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
      with:
        submodules: true # we need all syntax and theme submodules
    - name: Install Rust toolchain
-      uses: actions-rs/toolchain@v1
+      uses: dtolnay/rust-toolchain@stable
      with:
        toolchain: stable
        default: true
        profile: minimal
    - name: Build and install bat
-      uses: actions-rs/cargo@v1
+      run: cargo install --locked --path .
      with:
        command: install
        args: --locked --path .
    - name: Rebuild binary assets (syntaxes and themes)
      run: bash assets/create.sh
    - name: Build and install bat with updated assets
-      uses: actions-rs/cargo@v1
+      run: cargo install --locked --path .
      with:
        command: install
        args: --locked --path .
    - name: Run unit tests with new syntaxes and themes
-      uses: actions-rs/cargo@v1
+      run: cargo test --locked --release
      with:
        command: test
        args: --release
    - name: Run ignored-by-default unit tests with new syntaxes and themes
-      uses: actions-rs/cargo@v1
+      run: cargo test --locked --release --test assets -- --ignored
      with:
        command: test
        args: --release -- --ignored
    - name: Syntax highlighting regression test
      run: tests/syntax-tests/regression_test.sh
    - name: List of languages
      run: bat --list-languages
    - name: List of themes
      run: bat --list-themes
    - name: Test custom assets
      run: tests/syntax-tests/test_custom_assets.sh
  test_with_system_config:
    name: Run tests with system wide configuration
    runs-on: ubuntu-20.04
    steps:
    - name: Git checkout
      uses: actions/checkout@v4
    - name: Prepare environment variables
      run: |
        echo "BAT_SYSTEM_CONFIG_PREFIX=$GITHUB_WORKSPACE/tests/examples/system_config" >> $GITHUB_ENV
    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@stable
    - name: Build and install bat
      run: cargo install --locked --path .
    - name: Run unit tests
      run: cargo test --locked --test system_wide_config -- --ignored
  documentation:
    name: Documentation
    runs-on: ubuntu-20.04
    steps:
    - name: Git checkout
      uses: actions/checkout@v4
    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@stable
    - name: Check documentation
      env:
        RUSTDOCFLAGS: -D warnings
      run: cargo doc --locked --no-deps --document-private-items --all-features
    - name: Show man page
      run: man $(find . -name bat.1)
  cargo-audit:
    name: cargo audit
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: cargo audit
  build:
-    name: Build
+    name: ${{ matrix.job.target }} (${{ matrix.job.os }})
    runs-on: ${{ matrix.job.os }}
    needs: crate_metadata
    strategy:
      fail-fast: false
      matrix:
        job:
-          # { os, target, cargo-options, features, use-cross, toolchain }
+          - { target: aarch64-unknown-linux-gnu   , os: ubuntu-20.04, use-cross: true }
-          - { os: ubuntu-latest  , target: arm-unknown-linux-gnueabihf , use-cross: use-cross }
+          - { target: arm-unknown-linux-gnueabihf , os: ubuntu-20.04, use-cross: true }
-          - { os: ubuntu-18.04   , target: aarch64-unknown-linux-gnu   , use-cross: use-cross }
+          - { target: arm-unknown-linux-musleabihf, os: ubuntu-20.04, use-cross: true }
-          - { os: ubuntu-18.04   , target: i686-unknown-linux-gnu      , use-cross: use-cross }
+          - { target: i686-pc-windows-msvc        , os: windows-2019                  }
-          - { os: ubuntu-18.04   , target: i686-unknown-linux-musl     , use-cross: use-cross }
+          - { target: i686-unknown-linux-gnu      , os: ubuntu-20.04, use-cross: true }
-          - { os: ubuntu-18.04   , target: x86_64-unknown-linux-gnu    , use-cross: use-cross }
+          - { target: i686-unknown-linux-musl     , os: ubuntu-20.04, use-cross: true }
-          - { os: ubuntu-18.04   , target: x86_64-unknown-linux-musl   , use-cross: use-cross }
+          - { target: x86_64-apple-darwin         , os: macos-12                      }
-          - { os: ubuntu-16.04   , target: x86_64-unknown-linux-gnu    , use-cross: use-cross }
+          - { target: x86_64-pc-windows-gnu       , os: windows-2019                  }
-          - { os: macos-latest   , target: x86_64-apple-darwin         }
+          - { target: x86_64-pc-windows-msvc      , os: windows-2019                  }
-          # - { os: windows-latest , target: i686-pc-windows-gnu         }  ## disabled; linker errors (missing '_imp____acrt_iob_func')
+          - { target: x86_64-unknown-linux-gnu    , os: ubuntu-20.04, use-cross: true }
-          - { os: windows-latest , target: i686-pc-windows-msvc        }
+          - { target: x86_64-unknown-linux-musl   , os: ubuntu-20.04, use-cross: true }
-          # - { os: windows-latest , target: x86_64-pc-windows-gnu       }  ## disabled; linker errors (missing '_imp____acrt_iob_func')
+    env:
-          - { os: windows-latest , target: x86_64-pc-windows-msvc      }
+      BUILD_CMD: cargo
    steps:
-    - name: Git checkout
+    - name: Checkout source code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
    - name: Install prerequisites
      shell: bash
      run: |
        case ${{ matrix.job.target }} in
-          arm-unknown-linux-gnueabihf) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
+          arm-unknown-linux-*) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
          aarch64-unknown-linux-gnu) sudo apt-get -y update ; sudo apt-get -y install gcc-aarch64-linux-gnu ;;
        esac
-    - name: Initialize workflow variables
+
      id: vars
      shell: bash
      run: |
        # toolchain
        TOOLCHAIN="stable" ## default to "stable" toolchain
        # * specify alternate TOOLCHAIN for *-pc-windows-gnu targets; gnu targets on Windows are broken for the standard *-pc-windows-msvc toolchain (refs: <https://github.com/rust-lang/rust/issues/47048>, <https://github.com/rust-lang/rust/issues/53454>, <https://github.com/rust-lang/cargo/issues/6754>)
        case ${{ matrix.job.target }} in *-pc-windows-gnu) TOOLCHAIN="stable-${{ matrix.job.target }}" ;; esac;
        # * use requested TOOLCHAIN if specified
        if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
        echo set-output name=TOOLCHAIN::${TOOLCHAIN}
        echo ::set-output name=TOOLCHAIN::${TOOLCHAIN}
        # staging directory
        STAGING='_staging'
        echo set-output name=STAGING::${STAGING}
        echo ::set-output name=STAGING::${STAGING}
        # determine EXE suffix
        EXE_suffix="" ; case ${{ matrix.job.target }} in *-pc-windows-*) EXE_suffix=".exe" ;; esac;
        echo set-output name=EXE_suffix::${EXE_suffix}
        echo ::set-output name=EXE_suffix::${EXE_suffix}
        # parse commit reference info
        REF_NAME=${GITHUB_REF#refs/*/}
        unset REF_BRANCH ; case ${GITHUB_REF} in refs/heads/*) REF_BRANCH=${GITHUB_REF#refs/heads/} ;; esac;
        unset REF_TAG ; case ${GITHUB_REF} in refs/tags/*) REF_TAG=${GITHUB_REF#refs/tags/} ;; esac;
        REF_SHAS=${GITHUB_SHA:0:8}
        echo set-output name=REF_NAME::${REF_NAME}
        echo set-output name=REF_BRANCH::${REF_BRANCH}
        echo set-output name=REF_TAG::${REF_TAG}
        echo set-output name=REF_SHAS::${REF_SHAS}
        echo ::set-output name=REF_NAME::${REF_NAME}
        echo ::set-output name=REF_BRANCH::${REF_BRANCH}
        echo ::set-output name=REF_TAG::${REF_TAG}
        echo ::set-output name=REF_SHAS::${REF_SHAS}
        # parse target
        unset TARGET_ARCH ; case ${{ matrix.job.target }} in arm-unknown-linux-gnueabihf) TARGET_ARCH=arm ;; i686-*) TARGET_ARCH=i686 ;; x86_64-*) TARGET_ARCH=x86_64 ;; esac;
        echo set-output name=TARGET_ARCH::${TARGET_ARCH}
        echo ::set-output name=TARGET_ARCH::${TARGET_ARCH}
        unset TARGET_OS ; case ${{ matrix.job.target }} in *-linux-*) TARGET_OS=linux ;; *-apple-*) TARGET_OS=macos ;; *-windows-*) TARGET_OS=windows ;; esac;
        echo set-output name=TARGET_OS::${TARGET_OS}
        echo ::set-output name=TARGET_OS::${TARGET_OS}
        # package name
        PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
        PKG_BASENAME=${PROJECT_NAME}-${REF_TAG:-$REF_SHAS}-${{ matrix.job.target }}
        PKG_NAME=${PKG_BASENAME}${PKG_suffix}
        echo set-output name=PKG_suffix::${PKG_suffix}
        echo set-output name=PKG_BASENAME::${PKG_BASENAME}
        echo set-output name=PKG_NAME::${PKG_NAME}
        echo ::set-output name=PKG_suffix::${PKG_suffix}
        echo ::set-output name=PKG_BASENAME::${PKG_BASENAME}
        echo ::set-output name=PKG_NAME::${PKG_NAME}
        # deployable tag? (ie, leading "vM" or "M"; M == version number)
        unset DEPLOY ; if [[ $REF_TAG =~ ^[vV]?[0-9].* ]]; then DEPLOY='true' ; fi
        echo set-output name=DEPLOY::${DEPLOY:-<empty>/false}
        echo ::set-output name=DEPLOY::${DEPLOY}
        # DPKG architecture?
        unset DPKG_ARCH
        case ${{ matrix.job.target }} in
          aarch64-*-linux-*) DPKG_ARCH=arm64 ;;
          arm-*-linux-*hf) DPKG_ARCH=armhf ;;
          i686-*-linux-*) DPKG_ARCH=i686 ;;
          x86_64-*-linux-*) DPKG_ARCH=amd64 ;;
        esac;
        echo set-output name=DPKG_ARCH::${DPKG_ARCH}
        echo ::set-output name=DPKG_ARCH::${DPKG_ARCH}
        # DPKG version?
        unset DPKG_VERSION ; if [[ $REF_TAG =~ ^[vV]?[0-9].* ]]; then DPKG_VERSION=${REF_TAG/#[vV]/} ; fi
        echo set-output name=DPKG_VERSION::${DPKG_VERSION}
        echo ::set-output name=DPKG_VERSION::${DPKG_VERSION}
        # DPKG base name/conflicts?
        DPKG_BASENAME=${PROJECT_NAME}
        DPKG_CONFLICTS=${PROJECT_NAME}-musl
        case ${{ matrix.job.target }} in *-musl) DPKG_BASENAME=${PROJECT_NAME}-musl ; DPKG_CONFLICTS=${PROJECT_NAME} ;; esac;
        echo set-output name=DPKG_BASENAME::${DPKG_BASENAME}
        echo set-output name=DPKG_CONFLICTS::${DPKG_CONFLICTS}
        echo ::set-output name=DPKG_BASENAME::${DPKG_BASENAME}
        echo ::set-output name=DPKG_CONFLICTS::${DPKG_CONFLICTS}
        # DPKG name
        unset DPKG_NAME;
        if [[ -n $DPKG_ARCH && -n $DPKG_VERSION ]]; then DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb" ; fi
        echo set-output name=DPKG_NAME::${DPKG_NAME}
        echo ::set-output name=DPKG_NAME::${DPKG_NAME}
        # target-specific options
        # * CARGO_USE_CROSS (truthy)
        CARGO_USE_CROSS='true' ; case '${{ matrix.job.use-cross }}' in ''|0|f|false|n|no) unset CARGO_USE_CROSS ;; esac;
        echo set-output name=CARGO_USE_CROSS::${CARGO_USE_CROSS:-<empty>/false}
        echo ::set-output name=CARGO_USE_CROSS::${CARGO_USE_CROSS}
        # # * `arm` cannot be tested on ubuntu-* hosts (b/c testing is currently primarily done via comparison of target outputs with built-in outputs and the `arm` target is not executable on the host)
        JOB_DO_TESTING="true"
        case ${{ matrix.job.target }} in arm-*) unset JOB_DO_TESTING ;; esac;
        echo set-output name=JOB_DO_TESTING::${JOB_DO_TESTING:-<empty>/false}
        echo ::set-output name=JOB_DO_TESTING::${JOB_DO_TESTING}
        # # * test only library unit tests and binary for arm-type targets
        unset CARGO_TEST_OPTIONS
        unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-* | aarch64-*) CARGO_TEST_OPTIONS="--lib --bin ${PROJECT_NAME}" ;; esac;
        echo set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}
        echo ::set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}
        # * executable for `strip`?
        STRIP="strip" ; case ${{ matrix.job.target }} in arm-unknown-linux-gnueabihf) STRIP="arm-linux-gnueabihf-strip" ;; aarch64-unknown-linux-gnu) STRIP="aarch64-linux-gnu-strip" ;; *-pc-windows-msvc) STRIP="" ;; esac;
        echo set-output name=STRIP::${STRIP}
        echo ::set-output name=STRIP::${STRIP}
    - name: Create all needed build/work directories
      shell: bash
      run: |
        mkdir -p '${{ steps.vars.outputs.STAGING }}'
        mkdir -p '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}'
        mkdir -p '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/autocomplete'
        mkdir -p '${{ steps.vars.outputs.STAGING }}/dpkg'
    - name: Install Rust toolchain
-      uses: actions-rs/toolchain@v1
+      uses: dtolnay/rust-toolchain@stable
      with:
-        toolchain: ${{ steps.vars.outputs.TOOLCHAIN }}
+        targets: ${{ matrix.job.target }}
-        target: ${{ matrix.job.target }}
+
-        override: true
+    - name: Install cross
-        profile: minimal # minimal component installation (ie, no documentation)
+      if: matrix.job.use-cross
-    - name: Info
+      uses: taiki-e/install-action@v2
      with:
        tool: cross
    - name: Overwrite build command env variable
      if: matrix.job.use-cross
      shell: bash
      run: echo "BUILD_CMD=cross" >> $GITHUB_ENV
    - name: Show version information (Rust, cargo, GCC)
      shell: bash
      run: |
        gcc --version || true
@@ -223,221 +213,263 @@ jobs:
        rustup default
        cargo -V
        rustc -V
    - name: Build
-      uses: actions-rs/cargo@v1
+      shell: bash
-      with:
+      run: $BUILD_CMD build --locked --release --target=${{ matrix.job.target }}
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
+
-        command: build
+    - name: Set binary name & path
-        args: --release --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }}
+      id: bin
    - name: Test
      uses: actions-rs/cargo@v1
      with:
        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
        command: test
        args: --target=${{ matrix.job.target }} ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }}
    - name: bat test run
      uses: actions-rs/cargo@v1
      with:
        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
        command: run
        args: --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} -- --paging=never --color=always --theme=ansi-dark Cargo.toml src/config.rs
    - name: Check features regex-onig
      uses: actions-rs/cargo@v1
      with:
        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
        command: check
        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig
    - name: Check features regex-onig,git
      uses: actions-rs/cargo@v1
      with:
        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
        command: check
        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git
    - name: Check features regex-onig,paging
      uses: actions-rs/cargo@v1
      with:
        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
        command: check
        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,paging
    - name: Check features regex-onig,git,paging
      uses: actions-rs/cargo@v1
      with:
        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
        command: check
        args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git,paging
    - name: Upload build artifacts
      uses: actions/upload-artifact@master
      with:
        name: ${{ env.PROJECT_NAME }}-${{ matrix.job.target }}
        path: target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}
    - name: Package
      shell: bash
      run: |
-        ARCHIVE_DIR='${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/'
+        # Figure out suffix of binary
-        # Binary
+        EXE_suffix=""
-        cp 'target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' "$ARCHIVE_DIR"
+        case ${{ matrix.job.target }} in
          *-pc-windows-*) EXE_suffix=".exe" ;;
        esac;
-        # `strip` binary (if needed)
+        # Setup paths
-        if [ -n "${{ steps.vars.outputs.STRIP }}" ]; then "${{ steps.vars.outputs.STRIP }}" "$ARCHIVE_DIR/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}" ; fi
+        BIN_NAME="${{ needs.crate_metadata.outputs.name }}${EXE_suffix}"
        BIN_PATH="target/${{ matrix.job.target }}/release/${BIN_NAME}"
        # Let subsequent steps know where to find the binary
        echo "BIN_PATH=${BIN_PATH}" >> $GITHUB_OUTPUT
        echo "BIN_NAME=${BIN_NAME}" >> $GITHUB_OUTPUT
    - name: Set testing options
      id: test-options
      shell: bash
      run: |
        # test only library unit tests and binary for arm-type targets
        unset CARGO_TEST_OPTIONS
        unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-* | aarch64-*) CARGO_TEST_OPTIONS="--lib --bin ${{ needs.crate_metadata.outputs.name }}" ;; esac;
        echo "CARGO_TEST_OPTIONS=${CARGO_TEST_OPTIONS}" >> $GITHUB_OUTPUT
    - name: Run tests
      shell: bash
      run: |
        if [[ ${{ matrix.job.os }} = windows-* ]]
        then
          powershell.exe -command "$BUILD_CMD test --locked --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}}"
        else
          $BUILD_CMD test --locked --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}}
        fi
    - name: Run bat
      shell: bash
      run: $BUILD_CMD run --locked --target=${{ matrix.job.target }} -- --paging=never --color=always --theme=ansi Cargo.toml src/config.rs
    - name: Show diagnostics (bat --diagnostic)
      shell: bash
      run: $BUILD_CMD run --locked --target=${{ matrix.job.target }} -- --paging=never --color=always --theme=ansi Cargo.toml src/config.rs --diagnostic
    - name: "Feature check: regex-onig"
      shell: bash
      run: $BUILD_CMD check --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig
    - name: "Feature check: regex-onig,git"
      shell: bash
      run: $BUILD_CMD check --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git
    - name: "Feature check: regex-onig,paging"
      shell: bash
      run: $BUILD_CMD check --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,paging
    - name: "Feature check: regex-onig,git,paging"
      shell: bash
      run: $BUILD_CMD check --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git,paging
    - name: "Feature check: minimal-application"
      shell: bash
      run: $BUILD_CMD check --locked --target=${{ matrix.job.target }} --verbose --no-default-features --features minimal-application
    - name: Create tarball
      id: package
      shell: bash
      run: |
        PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
        PKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-v${{ needs.crate_metadata.outputs.version }}-${{ matrix.job.target }}
        PKG_NAME=${PKG_BASENAME}${PKG_suffix}
        echo "PKG_NAME=${PKG_NAME}" >> $GITHUB_OUTPUT
        PKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/package"
        ARCHIVE_DIR="${PKG_STAGING}/${PKG_BASENAME}/"
        mkdir -p "${ARCHIVE_DIR}"
        mkdir -p "${ARCHIVE_DIR}/autocomplete"
        # Binary
        cp "${{ steps.bin.outputs.BIN_PATH }}" "$ARCHIVE_DIR"
        # README, LICENSE and CHANGELOG files
        cp "README.md" "LICENSE-MIT" "LICENSE-APACHE" "CHANGELOG.md" "$ARCHIVE_DIR"
        # Man page
-        cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/manual/bat.1 "$ARCHIVE_DIR"
+        cp 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'-*/out/assets/manual/bat.1 "$ARCHIVE_DIR"
        # README and LICENSE files
        cp "README.md" "LICENSE-MIT" "LICENSE-APACHE" "$ARCHIVE_DIR"
        # Autocompletion files
-        cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.fish "$ARCHIVE_DIR/autocomplete/${{ env.PROJECT_NAME }}.fish"
+        cp 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'-*/out/assets/completions/bat.bash "$ARCHIVE_DIR/autocomplete/${{ needs.crate_metadata.outputs.name }}.bash"
-        cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.zsh "$ARCHIVE_DIR/autocomplete/${{ env.PROJECT_NAME }}.zsh"
+        cp 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'-*/out/assets/completions/bat.fish "$ARCHIVE_DIR/autocomplete/${{ needs.crate_metadata.outputs.name }}.fish"
        cp 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'-*/out/assets/completions/_bat.ps1 "$ARCHIVE_DIR/autocomplete/_${{ needs.crate_metadata.outputs.name }}.ps1"
        cp 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'-*/out/assets/completions/bat.zsh "$ARCHIVE_DIR/autocomplete/${{ needs.crate_metadata.outputs.name }}.zsh"
        # base compressed package
-        pushd '${{ steps.vars.outputs.STAGING }}/' >/dev/null
+        pushd "${PKG_STAGING}/" >/dev/null
        case ${{ matrix.job.target }} in
-          *-pc-windows-*) 7z -y a '${{ steps.vars.outputs.PKG_NAME }}' '${{ steps.vars.outputs.PKG_BASENAME }}'/* | tail -2 ;;
+          *-pc-windows-*) 7z -y a "${PKG_NAME}" "${PKG_BASENAME}"/* | tail -2 ;;
-          *) tar czf '${{ steps.vars.outputs.PKG_NAME }}' '${{ steps.vars.outputs.PKG_BASENAME }}'/* ;;
+          *) tar czf "${PKG_NAME}" "${PKG_BASENAME}"/* ;;
        esac;
        popd >/dev/null
-        # Debian package
+        # Let subsequent steps know where to find the compressed package
-        if [ -n "${{ steps.vars.outputs.DPKG_NAME }}" ]; then
+        echo "PKG_PATH=${PKG_STAGING}/${PKG_NAME}" >> $GITHUB_OUTPUT
          DPKG_DIR="${{ steps.vars.outputs.STAGING }}/dpkg"
-          # Binary
+    - name: Create Debian package
-          install -Dm755 'target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' "${DPKG_DIR}/usr/bin/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}"
+      id: debian-package
-          if [ -n "${{ steps.vars.outputs.STRIP }}" ]; then "${{ steps.vars.outputs.STRIP }}" "${DPKG_DIR}/usr/bin/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}" ; fi
+      shell: bash
      if: startsWith(matrix.job.os, 'ubuntu')
      run: |
        COPYRIGHT_YEARS="2018 - "$(date "+%Y")
        DPKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/debian-package"
        DPKG_DIR="${DPKG_STAGING}/dpkg"
        mkdir -p "${DPKG_DIR}"
-          # Man page
+        DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}
-          install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/manual/bat.1 "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
+        DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }}-musl
-          gzip --best "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
+        case ${{ matrix.job.target }} in *-musl) DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-musl ; DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }} ;; esac;
        DPKG_VERSION=${{ needs.crate_metadata.outputs.version }}
-          # Autocompletion files
+        unset DPKG_ARCH
-          install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.fish "${DPKG_DIR}/usr/share/fish/vendor_completions.d/${{ env.PROJECT_NAME }}.fish"
+        case ${{ matrix.job.target }} in
-          install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.zsh "${DPKG_DIR}/usr/share/zsh/vendor-completions/_${{ env.PROJECT_NAME }}"
+          aarch64-*-linux-*) DPKG_ARCH=arm64 ;;
          arm-*-linux-*hf) DPKG_ARCH=armhf ;;
          i686-*-linux-*) DPKG_ARCH=i686 ;;
          x86_64-*-linux-*) DPKG_ARCH=amd64 ;;
          *) DPKG_ARCH=notset ;;
        esac;
-          # README and LICENSE
+        DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb"
-          install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${{ env.PROJECT_NAME }}/README.md"
+        echo "DPKG_NAME=${DPKG_NAME}" >> $GITHUB_OUTPUT
          install -Dm644 "LICENSE-MIT" "${DPKG_DIR}/usr/share/doc/${{ env.PROJECT_NAME }}/LICENSE-MIT"
          install -Dm644 "LICENSE-APACHE" "${DPKG_DIR}/usr/share/doc/${{ env.PROJECT_NAME }}/LICENSE-APACHE"
-          cat > "${DPKG_DIR}/usr/share/doc/${{ env.PROJECT_NAME }}/copyright" <<EOF
+        # Binary
        install -Dm755 "${{ steps.bin.outputs.BIN_PATH }}" "${DPKG_DIR}/usr/bin/${{ steps.bin.outputs.BIN_NAME }}"
        # Man page
        install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'-*/out/assets/manual/bat.1 "${DPKG_DIR}/usr/share/man/man1/${{ needs.crate_metadata.outputs.name }}.1"
        gzip -n --best "${DPKG_DIR}/usr/share/man/man1/${{ needs.crate_metadata.outputs.name }}.1"
        # Autocompletion files
        install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'-*/out/assets/completions/bat.bash "${DPKG_DIR}/usr/share/bash-completion/completions/${{ needs.crate_metadata.outputs.name }}"
        install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'-*/out/assets/completions/bat.fish "${DPKG_DIR}/usr/share/fish/vendor_completions.d/${{ needs.crate_metadata.outputs.name }}.fish"
        install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ needs.crate_metadata.outputs.name }}'-*/out/assets/completions/bat.zsh "${DPKG_DIR}/usr/share/zsh/vendor-completions/_${{ needs.crate_metadata.outputs.name }}"
        # README and LICENSE
        install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/README.md"
        install -Dm644 "LICENSE-MIT" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-MIT"
        install -Dm644 "LICENSE-APACHE" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-APACHE"
        install -Dm644 "CHANGELOG.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/changelog"
        gzip -n --best "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/changelog"
        cat > "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright" <<EOF
        Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-        Upstream-Name: ${{ env.PROJECT_NAME }}
+        Upstream-Name: ${{ needs.crate_metadata.outputs.name }}
-        Source: ${{ env.PROJECT_HOMEPAGE }}
+        Source: ${{ needs.crate_metadata.outputs.homepage }}
        Files: *
-        Copyright: ${{ env.PROJECT_MAINTAINER }}
+        Copyright: ${{ needs.crate_metadata.outputs.maintainer }}
        Copyright: $COPYRIGHT_YEARS ${{ needs.crate_metadata.outputs.maintainer }}
        License: Apache-2.0 or MIT
        License: Apache-2.0
-         On Debian systems, the complete text of the Apache-2.0 can be found in the
+          On Debian systems, the complete text of the Apache-2.0 can be found in the
-         file /usr/share/common-licenses/Apache-2.0.
+          file /usr/share/common-licenses/Apache-2.0.
        License: MIT
-         Permission is hereby granted, free of charge, to any
+          Permission is hereby granted, free of charge, to any
-         person obtaining a copy of this software and associated
+          person obtaining a copy of this software and associated
-         documentation files (the "Software"), to deal in the
+          documentation files (the "Software"), to deal in the
-         Software without restriction, including without
+          Software without restriction, including without
-         limitation the rights to use, copy, modify, merge,
+          limitation the rights to use, copy, modify, merge,
-         publish, distribute, sublicense, and/or sell copies of
+          publish, distribute, sublicense, and/or sell copies of
-         the Software, and to permit persons to whom the Software
+          the Software, and to permit persons to whom the Software
-         is furnished to do so, subject to the following
+          is furnished to do so, subject to the following
-         conditions:
+          conditions:
-         .
+          .
-         The above copyright notice and this permission notice
+          The above copyright notice and this permission notice
-         shall be included in all copies or substantial portions
+          shall be included in all copies or substantial portions
-         of the Software.
+          of the Software.
-         .
+          .
-         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+          THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-         ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+          ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-         TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+          TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-         PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+          PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-         SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+          SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-         CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+          CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-         OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+          OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-         IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+          IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-         DEALINGS IN THE SOFTWARE.
+          DEALINGS IN THE SOFTWARE.
        EOF
          chmod 644 "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright"
          # control file
          mkdir -p "${DPKG_DIR}/DEBIAN"
          cat > "${DPKG_DIR}/DEBIAN/control" <<EOF
-        Package: ${{ steps.vars.outputs.DPKG_BASENAME }}
+        Package: ${DPKG_BASENAME}
-        Version: ${{ steps.vars.outputs.DPKG_VERSION }}
+        Version: ${DPKG_VERSION}
        Section: utils
        Priority: optional
-        Maintainer: ${{ env.PROJECT_MAINTAINER }}
+        Maintainer: ${{ needs.crate_metadata.outputs.maintainer }}
-        Homepage: ${{ env.PROJECT_HOMEPAGE }}
+        Homepage: ${{ needs.crate_metadata.outputs.homepage }}
-        Architecture: ${{ steps.vars.outputs.DPKG_ARCH }}
+        Architecture: ${DPKG_ARCH}
-        Provides: ${{ env.PROJECT_NAME }}
+        Provides: ${{ needs.crate_metadata.outputs.name }}
-        Conflicts: ${{ steps.vars.outputs.DPKG_CONFLICTS }}
+        Conflicts: ${DPKG_CONFLICTS}
-        Description: A cat(1) clone with wings.
+        Description: cat(1) clone with wings.
-         A cat(1) clone with syntax highlighting and Git integration.
+          A cat(1) clone with syntax highlighting and Git integration.
        EOF
-          # build dpkg
+        DPKG_PATH="${DPKG_STAGING}/${DPKG_NAME}"
-          fakeroot dpkg-deb --build "${DPKG_DIR}" "${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.DPKG_NAME }}"
+        echo "DPKG_PATH=${DPKG_PATH}" >> $GITHUB_OUTPUT
-        fi
+
        # build dpkg
        fakeroot dpkg-deb --build "${DPKG_DIR}" "${DPKG_PATH}"
    - name: "Artifact upload: tarball"
      uses: actions/upload-artifact@master
      with:
        name: ${{ steps.package.outputs.PKG_NAME }}
        path: ${{ steps.package.outputs.PKG_PATH }}
    - name: "Artifact upload: Debian package"
      uses: actions/upload-artifact@master
      if: steps.debian-package.outputs.DPKG_NAME
      with:
        name: ${{ steps.debian-package.outputs.DPKG_NAME }}
        path: ${{ steps.debian-package.outputs.DPKG_PATH }}
    - name: Check for release
      id: is-release
      shell: bash
      run: |
        unset IS_RELEASE ; if [[ $GITHUB_REF =~ ^refs/tags/v[0-9].* ]]; then IS_RELEASE='true' ; fi
        echo "IS_RELEASE=${IS_RELEASE}" >> $GITHUB_OUTPUT
    - name: Publish archives and packages
      uses: softprops/action-gh-release@v1
-      if: steps.vars.outputs.DEPLOY
+      if: steps.is-release.outputs.IS_RELEASE
      with:
        files: |
-          ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_NAME }}
+          ${{ steps.package.outputs.PKG_PATH }}
-          ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.DPKG_NAME }}
+          ${{ steps.debian-package.outputs.DPKG_PATH }}
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-  coverage:
+  winget:
-    name: Code Coverage
+    name: Publish to Winget
-    runs-on: ${{ matrix.job.os }}
+    runs-on: ubuntu-latest
-    strategy:
+    needs: build
-      fail-fast: true
+    if: startsWith(github.ref, 'refs/tags/v')
      matrix:
        # job: [ { os: ubuntu-latest }, { os: macos-latest }, { os: windows-latest } ]
        job:
          - { os: ubuntu-latest , toolchain: nightly-2020-04-29 }
          - { os: macos-latest , toolchain: nightly-2020-04-29 }
          - { os: windows-latest , toolchain: nightly-2020-04-29-x86_64-pc-windows-gnu }
    steps:
-    - uses: actions/checkout@v2
+      - uses: vedantmgoyal2009/winget-releaser@v2
-    - name: Initialize workflow variables
+        with:
-      id: vars
+          identifier: sharkdp.bat
-      shell: bash
+          installers-regex: '-pc-windows-msvc\.zip$'
-      run: |
+          token: ${{ secrets.WINGET_TOKEN }}
        # toolchain
        TOOLCHAIN="nightly" ## default to "nightly" toolchain
        # * use requested TOOLCHAIN if specified
        if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
        # * use requested TOOLCHAIN if specified
        if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
        echo set-output name=TOOLCHAIN::${TOOLCHAIN}
        echo ::set-output name=TOOLCHAIN::${TOOLCHAIN}
        # target-specific options
        # * CODECOV_FLAGS
        CODECOV_FLAGS=$( echo "${{ matrix.job.os }}" | sed 's/[^[:alnum:]]/_/g' )
        echo set-output name=CODECOV_FLAGS::${CODECOV_FLAGS}
        echo ::set-output name=CODECOV_FLAGS::${CODECOV_FLAGS}
    - name: rust toolchain ~ install
      uses: actions-rs/toolchain@v1
      with:
        toolchain: ${{ steps.vars.outputs.TOOLCHAIN }}
        override: true
        profile: minimal # minimal component installation (ie, no documentation)
    - name: Test
      uses: actions-rs/cargo@v1
      with:
        command: test
        args: --no-fail-fast
      env:
        CARGO_INCREMENTAL: '0'
        RUSTFLAGS: '-Zprofile -Ccodegen-units=1 -Cinline-threshold=0 -Clink-dead-code -Coverflow-checks=off -Zno-landing-pads'
    - name: Generate coverage data
      id: coverage
      uses: actions-rs/grcov@v0.1
    - name: Upload coverage results (to Codecov.io)
      uses: codecov/codecov-action@v1
      with:
        file: ${{ steps.coverage.outputs.report }}
        flags: ${{ steps.vars.outputs.CODECOV_FLAGS }}
        name: codecov-umbrella
        fail_ci_if_error: false
@@ -2,6 +2,7 @@
 **/*.rs.bk
 # Generated files
 /assets/completions/bat.bash
 /assets/completions/bat.fish
 /assets/completions/bat.zsh
 /assets/manual/bat.1
@@ -61,18 +61,12 @@
 [submodule "assets/syntaxes/Puppet"]
 	path = assets/syntaxes/02_Extra/Puppet
 	url = https://github.com/russCloak/SublimePuppet
 [submodule "assets/syntaxes/CSV"]
 	path = assets/syntaxes/02_Extra/CSV
 	url = https://github.com/wadetb/Sublime-Text-Advanced-CSV
 [submodule "assets/themes/onehalf"]
 	path = assets/themes/onehalf
 	url = https://github.com/sonph/onehalf
 [submodule "assets/syntaxes/JavaScript (Babel)"]
 	path = assets/syntaxes/02_Extra/JavaScript (Babel)
 	url = https://github.com/babel/babel-sublime
 [submodule "assets/syntaxes/Dart"]
 	path = assets/syntaxes/02_Extra/Dart
 	url = https://github.com/guillermooo/dart-sublime-bundle
 [submodule "assets/syntaxes/FSharp"]
 	path = assets/syntaxes/02_Extra/FSharp
 	url = https://github.com/hoest/sublimetext-fsharp
@@ -97,10 +91,6 @@
 [submodule "assets/syntaxes/Assembly (ARM)"]
 	path = assets/syntaxes/02_Extra/Assembly (ARM)
 	url = https://github.com/tvi/Sublime-ARM-Assembly
 [submodule "assets/syntaxes/syslog-syntax"]
 	path = assets/syntaxes/02_Extra/Syslog
 	url = https://github.com/caos21/syslog-syntax.git
 	branch = master
 [submodule "assets/syntaxes/protobuf-syntax-highlighting"]
 	path = assets/syntaxes/02_Extra/Protobuf
 	url = https://github.com/VcamX/protobuf-syntax-highlighting.git
@@ -120,9 +110,6 @@
 [submodule "assets/syntaxes/Org mode"]
 	path = assets/syntaxes/02_Extra/Org mode
 	url = https://github.com/jezcope/Org.tmbundle.git
 [submodule "assets/syntaxes/requirementstxt"]
 	path = assets/syntaxes/02_Extra/requirementstxt
 	url = https://github.com/wuub/requirementstxt
 [submodule "assets/syntaxes/DotENV"]
 	path = assets/syntaxes/02_Extra/DotENV
 	url = https://github.com/zaynali53/DotENV
@@ -185,9 +172,6 @@
 [submodule "assets/syntaxes/02_Extra/AsciiDoc"]
 	path = assets/syntaxes/02_Extra/AsciiDoc
 	url = https://github.com/asciidoctor/sublimetext-asciidoc.git
 [submodule "assets/themes/gruvbox"]
 	path = assets/themes/gruvbox
 	url = https://github.com/peaceant/gruvbox.git
 [submodule "assets/syntaxes/02_Extra/GLSL"]
 	path = assets/syntaxes/02_Extra/GLSL
 	url = https://github.com/euler0/sublime-glsl
@@ -206,3 +190,73 @@
 [submodule "assets/themes/Coldark"]
 	path = assets/themes/Coldark
 	url = https://github.com/ArmandPhilippot/coldark-bat.git
 [submodule "assets/themes/gruvbox"]
 	path = assets/themes/gruvbox
 	url = https://github.com/subnut/gruvbox-tmTheme.git
 	branch = bat-source
 [submodule "assets/syntaxes/02_Extra/Lean"]
 	path = assets/syntaxes/02_Extra/Lean
 	url = https://github.com/leanprover/vscode-lean.git
 [submodule "assets/syntaxes/02_Extra/LiveScript"]
 	path = assets/syntaxes/02_Extra/LiveScript
 	url = https://github.com/paulmillr/LiveScript.tmbundle
 [submodule "assets/syntaxes/02_Extra/Zig"]
 	path = assets/syntaxes/02_Extra/Zig
 	url = https://github.com/ziglang/sublime-zig-language.git
 [submodule "assets/syntaxes/02_Extra/gnuplot"]
 	path = assets/syntaxes/02_Extra/gnuplot
 	url = https://github.com/hesstobi/sublime_gnuplot
 [submodule "assets/syntaxes/02_Extra/SystemVerilog"]
 	path = assets/syntaxes/02_Extra/SystemVerilog
 	url = https://github.com/TheClams/SystemVerilog.git
 [submodule "assets/themes/visual-studio-dark-plus"]
 	path = assets/themes/visual-studio-dark-plus
 	url = https://github.com/vidann1/visual-studio-dark-plus.git
 [submodule "assets/syntaxes/02_Extra/SublimeEthereum"]
 	path = assets/syntaxes/02_Extra/SublimeEthereum
 	url = https://github.com/davidhq/SublimeEthereum.git
 [submodule "assets/syntaxes/02_Extra/Groff"]
 	path = assets/syntaxes/02_Extra/Groff
 	url = https://github.com/carsonoid/sublime_man_page_support
 [submodule "assets/syntaxes/02_Extra/http-request-response"]
 	path = assets/syntaxes/02_Extra/http-request-response
 	url = https://github.com/keith-hall/http-request-response-syntax.git
 [submodule "assets/syntaxes/02_Extra/LLVM"]
 	path = assets/syntaxes/02_Extra/LLVM
 	url = https://github.com/ioncodes/LLVM.tmBundle
 [submodule "assets/syntaxes/02_Extra/Slim"]
 	path = assets/syntaxes/02_Extra/Slim
 	url = https://github.com/slim-template/ruby-slim.tmbundle.git
 [submodule "assets/syntaxes/02_Extra/Racket"]
 	path = assets/syntaxes/02_Extra/Racket
 	url = https://github.com/follesoe/sublime-racket.git
 [submodule "assets/syntaxes/02_Extra/MediaWiki"]
 	path = assets/syntaxes/02_Extra/MediaWiki
 	url = https://github.com/tosher/Mediawiker.git
 [submodule "assets/syntaxes/02_Extra/Dart"]
 	path = assets/syntaxes/02_Extra/Dart
 	url = https://github.com/elMuso/Dartlight.git
 [submodule "assets/syntaxes/02_Extra/SublimeJQ"]
 	path = assets/syntaxes/02_Extra/SublimeJQ
 	url = https://github.com/zogwarg/SublimeJQ.git
 [submodule "assets/syntaxes/02_Extra/cmd-help"]
 	path = assets/syntaxes/02_Extra/cmd-help
 	url = https://github.com/victor-gp/cmd-help-sublime-syntax.git
 	branch = main
 	shallow = true
 [submodule "assets/syntaxes/02_Extra/TodoTxt"]
 	path = assets/syntaxes/02_Extra/TodoTxt
 	url = https://github.com/dertuxmalwieder/SublimeTodoTxt
 [submodule "assets/syntaxes/02_Extra/Ada"]
 	path = assets/syntaxes/02_Extra/Ada
 	url = https://github.com/wiremoons/ada-sublime-syntax
 [submodule "assets/syntaxes/02_Extra/Crontab"]
 	path = assets/syntaxes/02_Extra/Crontab
 	url = https://github.com/michaelblyons/SublimeSyntax-Crontab
 [submodule "assets/syntaxes/02_Extra/NSIS"]
 	path = assets/syntaxes/02_Extra/NSIS
 	url = https://github.com/SublimeText/NSIS
 [submodule "assets/syntaxes/02_Extra/vscode-wgsl"]
 	path = assets/syntaxes/02_Extra/vscode-wgsl
 	url = https://github.com/PolyMeilex/vscode-wgsl.git
@@ -1,19 +1,351 @@
-# unreleased
+# v0.24.0
 ## Features
 - Add environment variable `BAT_PAGING`, see #2629 (@einfachIrgendwer0815)
 - Add opt-in (`--features lessopen`) support for `LESSOPEN` and `LESSCLOSE`. See #1597, #1739, #2444, #2602, and #2662 (@Anomalocaridid)
 ## Bugfixes
 - Fix `more` not being found on Windows when provided via `BAT_PAGER`, see #2570, #2580, and #2651 (@mataha)
 - Switched default behavior of `--map-syntax` to be case insensitive #2520
 - Updated version of `serde_yaml` to `0.9`. See #2627 (@Raghav-Bell)
 - Fix arithmetic overflow in `LineRange::from` and `LineRange::parse_range`, see #2674, #2698 (@skoriop)
 - Fix paging not happening when stdout is interactive but stdin is not, see #2574 (@Nigecat)
 - Make `-pp` override `--paging` and vice versa when passed as a later argument, see #2660 (@J-Kappes)
 ## Other
 - Output directory for generated assets (completion, manual) can be customized, see #2515 (@tranzystorek-io)
 - Use the `is-terminal` crate instead of `atty`, see #2530 (@nickelc)
 - Add Winget Releaser workflow, see #2519 (@sitiom)
 - Bump MSRV to 1.70, see #2651 (@mataha)
 ## Syntaxes
-## New themes
+- Associate `os-release` with `bash` syntax, see #2587 (@cyqsimon)
 - Associate `Containerfile` with `Dockerfile` syntax, see #2606 (@einfachIrgendwer0815)
 - Replaced quotes with double quotes so fzf integration example script works on windows and linux. see #2095 (@johnmatthiggins)
 - Associate `ksh` files with `bash` syntax, see #2633 (@johnmatthiggins)
 - Associate `sarif` files with `JSON` syntax, see #2695 (@rhysd)
 - Associate `ron` files with `rust` syntax, see #2427 (@YeungOnion)
 - Add support for [WebGPU Shader Language](https://www.w3.org/TR/WGSL/), see #2692 (@rhysd)
 - Add `.dpkg-new` and `.dpkg-tmp` to ignored suffixe, see #2595 (@scop)
 - fix: Add syntax mapping `*.jsonl` => `json`, see #2539 (@WinterCore)
 - Update `Julia` syntax, see #2553 (@dependabot)
 - add `NSIS` support, see #2577 (@idleberg)
 - Update `ssh-config`, see #2697 (@mrmeszaros)
 ## `bat` as a library
-## Packaging
+- Add optional output_buffer arg to `Controller::run()` and `Controller::run_with_error_handler()`, see #2618 (@Piturnah)
 # v0.23.0
 ## Features
 - Implemented `-S` and `--chop-long-lines` flags as aliases for `--wrap=never`. See #2309 (@johnmatthiggins)
 - Breaking change: Environment variables can now override config file settings (but command-line arguments still have the highest precedence), see #1152, #1281, and #2381 (@aaronkollasch)
 - Implemented `--nonprintable-notation=caret` to support showing non-printable characters using caret notation. See #2429 (@einfachIrgendwer0815)
 ## Bugfixes
 - Fix `bat cache --clear` not clearing the `--target` dir if specified. See #2393 (@miles170)
 ## Other
 - Various bash completion improvements, see #2310 (@scop)
 - Disable completion of `cache` subcommand, see #2399 (@cyqsimon)
 - Signifigantly improve startup performance on macOS, see #2442 (@BlackHoleFox)
 - Bump MSRV to 1.62, see #2496 (@Enselic)
 ## Syntaxes
 - Added support for Ada, see #1300 and #2316 (@dkm)
 - Added `todo.txt` syntax, see #2375 (@BANOnotIT)
 - Improve Manpage.sublime-syntax. See #2364 (@Freed-Wu) and #2461 (@keith-hall)
 - Added a new `requirements.txt` syntax, see #2361 (@Freed-Wu)
 - Added a new VimHelp syntax, see #2366 (@Freed-Wu)
 - Associate `pdm.lock` with `TOML` syntax, see #2410
 - `Todo.txt`: Fix highlighting of contexts and projects at beginning of done.txt, see #2411
 - `cmd-help`: overhaul scope names (colors) to improve theme support; misc syntax improvements. See #2419 (@victor-gp)
 - Added support for Crontab, see #2509 (@keith-hall)
 ## Themes
 ## `bat` as a library
 - `PrettyPrinter::header` correctly displays a header with the filename, see #2378 and #2406 (@cstyles)
 # v0.22.1
 ## Bugfixes
 - Bring back pre-processing of ANSI escape characters to so that some common `bat` use cases starts working again. See #2308 (@Enselic)
 # v0.22.0
 ## Features
 - Make the default macOS theme depend on Dark Mode. See #2197, #1746 (@Enselic)
 - Support for separate system and user config files. See #668 (@patrickpichler)
 ## Bugfixes
 - Prevent fork nightmare with `PAGER=batcat`. See #2235 (@johnmatthiggins)
 - Make `--no-paging`/`-P` override `--paging=...` if passed as a later arg, see #2201 (@themkat)
 - `--map-syntax` and `--ignored-suffix` now works together, see #2093 (@czzrr)
 - Strips byte order mark from output when in non-loop-through mode. See #1922 (@dag-h)
 ## Other
 - Relaxed glibc requirements on amd64, see #2106 and #2194 (@sharkdp)
 - Improved fish completions. See #2275 (@zgracem)
 - Stop pre-processing ANSI escape characters. Syntax highlighting on ANSI escaped input is not supported. See #2185 and #2189 (@Enselic)
 ## Syntaxes
 - NSE (Nmap Scripting Engine) is mapped to Lua, see #2151 (@Cre3per)
 - Correctly color `fstab` dump and pass fields, see #2246 (@yuvalmo)
 - Update `Command Help` syntax, see #2255
 - `Julia`: Fix syntax highlighting for function name starting with `struct`, see #2230
 - Minor update to `LiveScript`, see #2291
 - Associate `.mts` and `.cts` files with the `TypeScript` syntax. See #2236 (@kidonng)
 - Fish history is mapped to YAML. See #2237 (@kidonng)
 ## `bat` as a library
 - Make `bat::PrettyPrinter::syntaxes()` iterate over new `bat::Syntax` struct instead of `&syntect::parsing::SyntaxReference`. See #2222 (@Enselic)
 - Clear highlights after printing, see #1919 and #1920 (@rhysd)
 # v0.21.0
 ## Features
 - Correctly render tab stops in `--show-all`, see #2038 (@Synthetica9)
 - Add a `--style=default` option and make it the default. It is less verbose than `full`, see #2061 (@IsaacHorvath)
 - Enable BusyBox `less` as pager, see #2162 (@nfisher1226)
 - File extensions are now matched case-insensitively. See #1854, #2181 (@Enselic)
 ## Bugfixes
 - Bump `regex` dependency from 1.5.4 to 1.5.5 to fix [CVE-2022-24713](https://blog.rust-lang.org/2022/03/08/cve-2022-24713.html), see #2145, #2139 (@Enselic)
 - `bat` no longer crashes when encountering files that references missing syntaxes. See #915, #2181 (@Enselic)
 ## Performance
 - Skip syntax highlighting on long lines (> 16384 chars) to help improve performance. See #2165 (@keith-hall)
 - Vastly improve startup time by lazy-loading syntaxes via syntect 5.0.0. This makes bat display small files ~75% faster than before. See #951, #2181 (@Enselic)
 ## Other
 - Include info about custom assets in `--diagnostics` if used. See #2107, #2144 (@Enselic)
 ## Syntaxes
 - Mapped clang-format config file (.clang-format) to YAML syntax (@TruncatedDinosour)
 - log syntax: improved handling of escape characters in double quoted strings. See #2123 (@keith-hall)
 - Associate `/var/spool/mail/*` and `/var/mail/*` with the `Email` syntax. See #2156 (@cyqsimon)
 - Added cmd-help syntax to scope --help messages. See #2148 (@victor-gp)
 - Slightly adjust Zig syntax. See #2136 (@Enselic)
 - Associate `.inf` files with the `INI` syntax. See #2190 (@Enselic)
 ## `bat` as a library
 - Allow configuration of `show_nonprintable` with `PrettyPrinter`, see #2142
 - The binary format of syntaxes.bin has been changed due to syntaxes now being lazy-loaded via syntect 5.0.0. See #2181 (@Enselic)
 - Mark `bat::error::Error` enum as `#[non_exhaustive]` to allow adding new variants without future semver breakage. See #2181 (@Enselic)
 - Change `Error::SyntectError(syntect::LoadingError)` to `Error::SyntectError(syntect::Error)`. See #2181 (@Enselic)
 - Add `Error::SyntectLoadingError(syntect::LoadingError)` enum variant. See #2181 (@Enselic)
 # v0.20.0
 ## Features
 - New style component `header-filesize` to show size of the displayed file in the header. See #1988 (@mdibaiee)
 - Use underline for line highlighting on ANSI, see #1730 (@mdibaiee)
 ## Bugfixes
 - Fix bash completion on bash 3.x and bash-completion 1.x. See #2066 (@joshpencheon)
 ## Syntaxes
 - `GraphQL`: Add support for interfaces implementing interfaces and consider ampersand an operator. See #2000
 - Associate `_vimrc` and `_gvimrc` files with the `VimL` syntax. See #2002
 - Associate `poetry.lock` files with the `TOML` syntax. See #2049
 - Associate `.mesh`, `.task`, `.rgen`, `.rint`, `.rahit`, `.rchit`, `.rmiss`, and `.rcall` with the `GLSL` syntax. See #2050
 - Added support for `JQ` syntax, see #2072
 - Properly associate global git config files rooted in `$XDG_CONFIG_HOME/git/` or `$HOME/.config/git/`. See #2067 (@cyqsimon)
 ## `bat` as a library
 - Exposed `get_syntax_set` and `get_theme` methods on `HighlightingAssets`. See #2030 (@dandavison)
 - Added `HeaderFilename` and `HeaderFilesize` to `StyleComponent` enum, and mark it `#[non_exhaustive]`. See #1988 (@mdibaiee)
 # v0.19.0
 ## Performance
 - Reduce startup time in loop-through mode (e.g. when redirecting output) by 90%. See #1747 (@Enselic)
 - Load themes lazily to make bat start 25% faster when disregarding syntax load time. See #1969 (@Enselic)
 - Python syntax highlighting no longer suffers from abysmal performance in specific scenarios. See #1688 (@keith-hall)
 - Fix for poor performance when ANSI escape sequences are piped to `bat`, see #1596 (@eth-p)
 - Fix for incorrect handling of ANSI escape sequences when using `--wrap=never`, see #1596 (@eth-p)
 - Load custom assets as fast as integrated assets, see #1753 (@Enselic)
 ## Features
 - Support for `x:-delta` (minus) syntax in line ranges (e.g. `20:-10`). See  #1901 (@bojan88)
 - Support for `--ignored-suffix` argument. See #1892 (@bojan88)
 - `$BAT_CONFIG_DIR` is now a recognized environment variable. It has precedence over `$XDG_CONFIG_HOME`, see #1727 (@billrisher)
 - Support for `x:+delta` syntax in line ranges (e.g. `20:+10`). See  #1810 (@bojan88)
 - Add new `--acknowledgements` option that gives credit to theme and syntax definition authors. See #1971 (@Enselic)
 - Include git hash in `bat -V` and `bat --version` output if present. See #1921 (@Enselic)
 ## Bugfixes
 - First line not shown in diff context. See #1891 (@divagant-martian)
 - Do not ignore syntaxes that handle file names with a `*.conf` extension. See #1703 (@cbolgiano)
 ## Other
 - Add PowerShell completion, see #1826 (@rashil2000)
 - Minimum supported Rust version (MSRV) bumped to 1.51, see #1994 (@mdibaiee)
 ## Syntaxes
 - Groff, see #1685 (@scop)
 - HTTP Requests and Responses, see #1748 (@keith-hall)
 - LLVM, see #1777 (@ioncodes)
 - Highlight for `vimrc` and `gvimrc` files, see #1763 (@SuperSandro2000)
 - Syslog highlighting improvements, see #1793 (@scop)
 - Added support for `slim` syntax, see #1693 (@mfinelli)
 - Racket, see #1884 (@jubnzv)
 - LiveScript, see #1915 (@Enselic)
 - MediaWiki, see #1925 (@sorairolake)
 - The `requirements.txt` syntax has been removed due to incompatible license requirements.
 - Dart, new highlighter, see #1959 (@Ersikan)
 - SCSS and Sass syntaxes updated, see #1766 (@Enselic)
 - PowerShell syntax updated, see #1935 (@Enselic)
 - TypeScript syntax updated, see #1834 (@Enselic)
 ## `bat` as a library
 - Deprecate `HighlightingAssets::syntaxes()` and `HighlightingAssets::syntax_for_file_name()`. Use `HighlightingAssets::get_syntaxes()` and `HighlightingAssets::get_syntax_for_path()` instead. They return a `Result` which is needed for upcoming lazy-loading work to improve startup performance. They also return which `SyntaxSet` the returned `SyntaxReference` belongs to. See #1747, #1755, #1776, #1862 (@Enselic)
 - Remove `HighlightingAssets::from_files` and `HighlightingAssets::save_to_cache`. Instead of calling the former and then the latter you now make a single call to `bat::assets::build`. See #1802, #1971 (@Enselic)
 - Replace  the `error::Error(error::ErrorKind, _)` struct and enum with an `error::Error` enum. `Error(ErrorKind::UnknownSyntax, _)` becomes `Error::UnknownSyntax`, etc. Also remove the `error::ResultExt` trait. These changes stem from replacing `error-chain` with `thiserror`. See #1820 (@Enselic)
 - Add new `MappingTarget` enum variant `MapExtensionToUnknown`. Refer to its documentation for more information. Also mark `MappingTarget` as `#[non_exhaustive]` since more enum variants might be added in the future. See #1703 (@cbolgiano), #2012 (@Enselic)
 # v0.18.3
 ## Bugfixes
 - Bump `git2` dependency to fix build with Rust 1.54, see #1761
 # v0.18.2
 ## Features
 - Ignore known backup/template filename suffixes when selecting the syntax, see #1687 (@scop)
 ## Bugfixes
 - Fix for a security vulnerability on Windows. Prior to this release, `bat` would execute programs called `less`/`less.exe` from the current working directory (instead of the one from `PATH`) with priority. An attacker might be able to use this by placing a malicious program in a shared directory where the user would execute `bat`. `bat` users on Windows are advised to upgrade to this version. See #1724 and #1472 (@Ry0taK).
 ## Other
 - Add bash completion, see #1678 (@scop)
 - Fix Clippy lints, see #1661 (@mohamed-abdelnour)
 - Add syntax highlighting test files, see #1213 and #1668 (@mohamed-abdelnour)
 ## Syntaxes
 - Upgraded Julia syntax to fix a highlighting bug, see #1692
 - Added support for `dash` syntax, see #1654 (@mohamed-abdelnour)
 - Added support for `XAML` syntax, see #1590 and #1655 (@mohamed-abdelnour)
 - Apply `DotENV` syntax also for `.env.default` and `.env.defaults` files, see #1669
 # v0.18.1
 ## Bugfixes
 - Mouse support and screen clearing broken for `less` versions with minor version number (581.2), see #1629 and #1639 (@aswild)
 ## Other
 - `Input::ordinary_file` and `Input::with_name` now accept `Path` rather than `OsStr` see #1571 (@matklad)
 - The `LESS` environment variable is now included in `bat --diagnostic`, see #1589 (@Enselic)
 - Increased min. required Rust version to 1.45
 ## Syntaxes
 - Improved the Syslog syntax highlighting, see #1606 (@keith-hall)
 - Replaced "Advanced CSV" with a custom CSV syntax definition written especially for `bat`; see #1574 (@keith-hall)
 - Added SystemVerilog file syntax, see #1580 (@SeanMcLoughlin)
 - Added Solidity and Vyper syntax, see #1602 (@Ersikan)
 ## New themes
 - Dark+ VS Code theme, see #1588 and #1598 (@PatriotRossii)
 # v0.18.0
 ## Features
 - Use a pager when `bat --list-languages` is called, see #1394 (@stku1985)
 ## Bugfixes
 - If the last line doesn't end with a newline character, don't add it if `--style=plain`, see #1438 (@Enselic)
 - Only print themes hint in interactive mode (`bat --list-themes`), see #1439 (@rsteube)
 - Make ./tests/syntax-tests/regression_test.sh work on recent versions of macOS, see #1443 (@Enselic)
 - VimL syntax highlighting fix, see #1450 (@esensar)
 - Print an 'Invalid syntax theme settings' error message if a custom theme is broken, see #614 (@Enselic)
 - If plain mode is set and wrap is not explicitly opted in, long lines will no be truncated, see #1426
 - If `PAGER` (but not `BAT_PAGER` or `--pager`) is `more` or `most`, silently use `less` instead to ensure support for colors, see #1063 (@Enselic)
 - If `PAGER` is `bat`, silently use `less` to prevent recursion. For `BAT_PAGER` or `--pager`, exit with error, see #1413 (@Enselic)
 - Manpage highlighting fix, see #1511 (@keith-hall)
 - `BAT_CONFIG_PATH` ignored by `bat` if non-existent, see #1550 (@sharkdp)
 ## Other
 - Performance improvements, see #1421 (@LovecraftianHorror)
 - Added a new `--diagnostic` option to collect information for bug reports, see #1459 (@sharkdp)
 - Modified default theme colors to differentiate between a JSON key and a string value, see #1400 (@keith-hall)
 - Upped min required Rust version to 1.42
 ## Syntaxes
 - Added Zig syntax, see #1470 (@paulsmith)
 - Added Lean syntax, see #1446 (@Julian)
 - Added `.resource` extension for Robot Framework files, see #1386
 - Added `gnuplot` syntax, see #1431 (@sharkdp)
 - Highlight *.pac (Proxy auto-config) files as JavaScript, see #1515 (@sharkdp)
 ## New themes
 - `ansi` replaces `ansi-dark` and `ansi-light`, see #1104 and #1412 (@mk12). **Breaking change:** users that were previously using one of the `ansi-*` themes should switch to `ansi`.
 - The Gruvbox theme has been updated, see #1291 (@j0hnmeow). **Breaking change:** users that were previously using `gruvbox` or `gruvbox-white` should update and use `gruvbox-dark`/`gruvbox-light` instead.
 ## `bat` as a library
 - The following `PrettyPrinter` methods have been removed (they were previously deprecated):
   - `input_stdin_with_name`
   - `input_from_bytes_with_name`
   - `input_from_reader_with_name`
   - `vcs_modification_markers` (if the `git` feature is not enabled)
 # v0.17.1
@@ -21,6 +353,7 @@
 - Running `bat` without arguments fails ("output file is also an input"), see #1396
 # v0.17.0
 ## Features
@@ -456,7 +789,7 @@ You can see the API documentation here: https://docs.rs/bat/
 - Added `BAT_CONFIG_PATH` environment variable to set a non-default path for `bat`s configuration file, see #375 (@deg4uss3r)
- Allow for multiple occurences of `--style` to allow for the configuration
+- Allow for multiple occurrences of `--style` to allow for the configuration
  of styles from the config file, see #367 (@sindreij)
 - Allow for multiple `--line-range` arguments, see #23
@@ -8,12 +8,12 @@ Thank you for considering to contribute to `bat`!
 If your contribution changes the behavior of `bat` (as opposed to a typo-fix
 in the documentation), please update the [`CHANGELOG.md`](CHANGELOG.md) file
-and describe your changes. This makes the release proess much easier and
+and describe your changes. This makes the release process much easier and
 therefore helps to get your changes into a new `bat` release faster.
 The top of the `CHANGELOG` contains a *"unreleased"* section with a few
 subsections (Features, Bugfixes, …). Please add your entry to the subsection
-that best describes your change
+that best describes your change.
 Entries follow this format:
 ```
@@ -33,7 +33,7 @@ section in the README.
 Please consider opening a
 [feature request ticket](https://github.com/sharkdp/bat/issues/new?assignees=&labels=feature-request&template=feature_request.md)
-first in order to give us a chance to discuss the feature first.
+first in order to give us a chance to discuss the details and specifics of the potential new feature before you go and build it.
 ## Adding new syntaxes/languages or themes
@@ -46,3 +46,25 @@ If you really think that a particular syntax or theme should be added for all
 users, please read the corresponding
 [documentation](https://github.com/sharkdp/bat/blob/master/doc/assets.md)
 first.
 ## Regression tests
 You are **strongly encouraged** to add regression tests. Regression tests are great,
 not least because they:
 * ensure that your contribution will never completely stop working.
 * makes code reviews easier, because it becomes very clear what the code is
  supposed to do.
 For functional changes, you most likely want to add a test to
 [`tests/integration_tests.rs`](https://github.com/sharkdp/bat/blob/master/tests/integration_tests.rs).
 Look at existing tests to know how to write a new test. In short, you will
 invoke the `bat` binary with a certain set of arguments, and then assert on
 stdout/stderr.
 To learn how to write regression tests for theme and syntax changes, read the
 [Syntax
 tests](https://github.com/sharkdp/bat/blob/master/doc/assets.md#syntax-tests)
 section in `assets.md`.
@@ -1,85 +1,109 @@
 [package]
 authors = ["David Peter <mail@david-peter.de>"]
 categories = ["command-line-utilities"]
-description="A cat(1) clone with wings."
+description = "A cat(1) clone with wings."
 homepage = "https://github.com/sharkdp/bat"
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 name = "bat"
 readme = "README.md"
 repository = "https://github.com/sharkdp/bat"
-version = "0.17.1"
+version = "0.24.0"
-exclude = [
+exclude = ["assets/syntaxes/*", "assets/themes/*"]
    "assets/syntaxes/*",
    "assets/themes/*",
 ]
 build = "build.rs"
 edition = '2018'
 rust-version = "1.70"
 [features]
 default = ["application"]
 # Feature required for bat the application. Should be disabled when depending on
 # bat as a library.
 application = [
-    "atty",
+    "bugreport",
-    "clap",
+    "build-assets",
    "dirs",
    "git",
-    "lazy_static",
+    "minimal-application",
 ]
 # Mainly for developers that want to iterate quickly
 # Be aware that the included features might change in the future
 minimal-application = [
    "clap",
    "etcetera",
    "paging",
    "wild",
    "regex-onig",
    "wild",
 ]
 git = ["git2"] # Support indicating git modifications
-paging = ["shell-words"] # Support applying a pager on the output
+paging = ["shell-words", "grep-cli"] # Support applying a pager on the output
 lessopen = ["run_script", "os_str_bytes"] # Support $LESSOPEN preprocessor
 build-assets = ["syntect/yaml-load", "syntect/plist-load", "regex", "walkdir"]
 # You need to use one of these if you depend on bat as a library:
 regex-onig = ["syntect/regex-onig"] # Use the "oniguruma" regex engine
 regex-fancy = ["syntect/regex-fancy"] # Use the rust-only "fancy-regex" engine
 [dependencies]
-atty = { version = "0.2.14", optional = true }
+nu-ansi-term = "0.49.0"
-ansi_term = "^0.12.1"
+ansi_colours = "^1.2"
-ansi_colours = "^1.0"
+bincode = "1.0"
-console = "0.13.0"
+console = "0.15.5"
-dirs = { version = "3.0", optional = true }
+flate2 = "1.0"
-lazy_static = { version = "1.4", optional = true }
+once_cell = "1.18"
-wild = { version = "2.0", optional = true }
+thiserror = "1.0"
 wild = { version = "2.1", optional = true }
 content_inspector = "0.2.4"
-encoding = "0.2"
+shell-words = { version = "1.1.0", optional = true }
-shell-words = { version = "1.0.0", optional = true }
+unicode-width = "0.1.10"
 unicode-width = "0.1.8"
 globset = "0.4"
 serde = { version = "1.0", features = ["derive"] }
-serde_yaml = "0.8"
+serde_yaml = "0.9"
-semver = "0.11"
+semver = "1.0"
 path_abs = { version = "0.5", default-features = false }
 clircle = "0.4"
 bugreport = { version = "0.5.0", optional = true }
 etcetera = { version = "0.8.0", optional = true }
 grep-cli = { version = "0.1.9", optional = true }
 regex = { version = "1.8.3", optional = true }
 walkdir = { version = "2.3", optional = true }
 bytesize = { version = "1.3.0" }
 encoding_rs = "0.8.33"
 os_str_bytes = { version = "~6.4", optional = true }
 run_script = { version = "^0.10.0", optional = true}
 [dependencies.git2]
-version = "0.13"
+version = "0.18"
 optional = true
 default-features = false
 [dependencies.syntect]
-version = "4.4.0"
+version = "5.0.0"
 default-features = false
-features = ["parsing", "yaml-load", "dump-load", "dump-create"]
+features = ["parsing"]
 [dependencies.clap]
-version = "2.33"
+version = "4.4.6"
 optional = true
-default-features = false
+features = ["wrap_help", "cargo"]
 features = ["suggestions", "color", "wrap_help"]
-[dependencies.error-chain]
+[target.'cfg(target_os = "macos")'.dependencies]
-version = "0.12"
+home = "0.5.4"
-default-features = false
+plist = "1.4.3"
 [dev-dependencies]
-tempdir = "0.3"
+assert_cmd = "2.0.10"
-assert_cmd = "1.0.1"
+expect-test = "1.4.1"
-predicates = "1.0.5"
+serial_test = { version = "2.0.0", default-features = false }
 predicates = "3.0.3"
 wait-timeout = "0.2.0"
 tempfile = "3.8.0"
-[build-dependencies]
+[target.'cfg(unix)'.dev-dependencies]
-clap = { version = "2.33", optional = true }
+nix = { version = "0.26.2", default-features = false, features = ["term"] }
 [build-dependencies.clap]
 version = "4.4.6"
 optional = true
 features = ["wrap_help", "cargo"]
 [profile.release]
 lto = true
 strip = true
 codegen-units = 1
@@ -1,4 +1,4 @@
-Copyright (c) 2018-2020 bat-developers (https://github.com/sharkdp/bat).
+Copyright (c) 2018-2023 bat-developers (https://github.com/sharkdp/bat).
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -0,0 +1,6 @@
 Copyright (c) 2018-2021 bat-developers (https://github.com/sharkdp/bat).
 bat is made available under the terms of either the MIT License or the Apache
 License 2.0, at your option.
 See the LICENSE-APACHE and LICENSE-MIT files for license details.
@@ -12,9 +12,36 @@
  <a href="#installation">Installation</a> •
  <a href="#customization">Customization</a> •
  <a href="#project-goals-and-alternatives">Project goals, alternatives</a><br>
-  [<a href="https://github.com/chinanf-boy/bat-zh">中文</a>] [<a href="doc/README-ja.md">日本語</a>] [<a href="doc/README-ko.md">한국어</a>] [<a href="doc/README-ru.md">Русский</a>]
+  [English]
  [<a href="doc/README-zh.md">中文</a>]
  [<a href="doc/README-ja.md">日本語</a>]
  [<a href="doc/README-ko.md">한국어</a>]
  [<a href="doc/README-ru.md">Русский</a>]
 </p>
 ### Sponsors
 A special *thank you* goes to our biggest <a href="doc/sponsors.md">sponsors</a>:<br>
 <a href="https://workos.com/?utm_campaign=github_repo&utm_medium=referral&utm_content=bat&utm_source=github">
  <img src="doc/sponsors/workos-logo-white-bg.svg" width="200" alt="WorkOS">
  <br>
  <strong>Your app, enterprise-ready.</strong>
  <br>
  <sub>Start selling to enterprise customers with just a few lines of code.</sub>
  <br>
  <sup>Add Single Sign-On (and more) in minutes instead of months.</sup>
 </a>
 <a href="https://www.warp.dev/?utm_source=github&utm_medium=referral&utm_campaign=bat_20231001">
  <img src="doc/sponsors/warp-logo.png" width="200" alt="Warp">
  <br>
  <strong>Warp is a modern, Rust-based terminal with AI built in<br>so you and your team can build great software, faster.</strong>
  <br>
  <sub>Feel more productive on the command line with parameterized commands,</sub>
  <br>
  <sup>autosuggestions, and an IDE-like text editor.</sup>
 </a>
 ### Syntax highlighting
 `bat` supports syntax highlighting for a large number of programming and markup
@@ -38,7 +65,7 @@ characters:
 ### Automatic paging
-By default, `bat` pipes its own output to a pager (e.g `less`) if the output is too large for one screen.
+By default, `bat` pipes its own output to a pager (e.g. `less`) if the output is too large for one screen.
 If you would rather `bat` work like `cat` all the time (never page output), you can set `--paging=never` as an option, either on the command line or in your configuration file.
 If you intend to alias `cat` to `bat` in your shell configuration, you can use `alias cat='bat --paging=never'` to preserve the default behavior.
@@ -94,14 +121,28 @@ bat f - g  # output 'f', then stdin, then 'g'.
 ### Integration with other tools
 #### `fzf`
 You can use `bat` as a previewer for [`fzf`](https://github.com/junegunn/fzf). To do this,
 use `bat`s `--color=always` option to force colorized output. You can also use `--line-range`
 option to restrict the load times for long files:
 ```bash
 fzf --preview "bat --color=always --style=numbers --line-range=:500 {}"
 ```
 For more information, see [`fzf`'s `README`](https://github.com/junegunn/fzf#preview-window).
 #### `find` or `fd`
 You can use the `-exec` option of `find` to preview all search results with `bat`:
 ```bash
 find … -exec bat {} +
 ```
 If you happen to use [`fd`](https://github.com/sharkdp/fd), you can use the `-X`/`--exec-batch` option to do the same:
 ```bash
 fd … -X bat
 ```
@@ -117,9 +158,11 @@ batgrep needle src/
 #### `tail -f`
 `bat` can be combined with `tail -f` to continuously monitor a given file with syntax highlighting.
 ```bash
 tail -f /var/log/pacman.log | bat --paging=never -l log
 ```
 Note that we have to switch off paging in order for this to work. We have also specified the syntax
 explicitly (`-l log`), as it can not be auto-detected in this case.
@@ -127,6 +170,7 @@ explicitly (`-l log`), as it can not be auto-detected in this case.
 You can combine `bat` with `git show` to view an older version of a given file with proper syntax
 highlighting:
 ```bash
 git show v0.6.0:src/main.rs | bat -l rs
 ```
@@ -137,7 +181,7 @@ You can combine `bat` with `git diff` to view lines around code changes with pro
 highlighting:
 ```bash
 batdiff() {
-    git diff --name-only --diff-filter=d | xargs bat --diff
+    git diff --name-only --relative --diff-filter=d | xargs bat --diff
 }
 ```
 If you prefer to use this as a separate tool, check out `batdiff` in [`bat-extras`](https://github.com/eth-p/bat-extras).
@@ -163,6 +207,7 @@ bat main.cpp | xclip
 export MANPAGER="sh -c 'col -bx | bat -l man -p'"
 man 2 select
 ```
 (replace `bat` with `batcat` if you are on Debian or Ubuntu)
 It might also be necessary to set `MANROFFOPT="-c"` if you experience
 formatting problems.
@@ -177,26 +222,52 @@ Also, note that this will [not work](https://github.com/sharkdp/bat/issues/1145)
 The [`prettybat`](https://github.com/eth-p/bat-extras/blob/master/doc/prettybat.md) script is a wrapper that will format code and print it with `bat`.
 #### Highlighting `--help` messages
 You can use `bat` to colorize help text: `$ cp --help | bat -plhelp`
 You can also use a wrapper around this:
 ```bash
 # in your .bashrc/.zshrc/*rc
 alias bathelp='bat --plain --language=help'
 help() {
    "$@" --help 2>&1 | bathelp
 }
 ```
 Then you can do `$ help cp` or `$ help git commit`.
 When you are using `zsh`, you can also use global aliases to override `-h` and `--help` entirely:
 ```bash
 alias -g -- -h='-h 2>&1 | bat --language=help --style=plain'
 alias -g -- --help='--help 2>&1 | bat --language=help --style=plain'
 ```
 This way, you can keep on using `cp --help`, but get colorized help pages.
 Be aware that in some cases, `-h` may not be a shorthand of `--help` (for example with `ls`).
 Please report any issues with the help syntax in [this repository](https://github.com/victor-gp/cmd-help-sublime-syntax).
 ## Installation
-[![Packaging status](https://repology.org/badge/vertical-allrepos/bat.svg)](https://repology.org/project/bat/versions)
+[![Packaging status](https://repology.org/badge/vertical-allrepos/bat-cat.svg)](https://repology.org/project/bat-cat/versions)
 ### On Ubuntu (using `apt`)
 *... and other Debian-based Linux distributions.*
-`bat` is making its way through the [Ubuntu](https://packages.ubuntu.com/eoan/bat) and
+`bat` is available on [Ubuntu since 20.04 ("Focal")](https://packages.ubuntu.com/search?keywords=bat&exact=1) and [Debian since August 2021 (Debian 11 - "Bullseye")](https://packages.debian.org/bullseye/bat).
 [Debian](https://packages.debian.org/sid/bat) package release process, and is available
 for Ubuntu as of Eoan 19.10. On Debian `bat` is currently only available on the unstable
 "Sid" branch.
 If your Ubuntu/Debian installation is new enough you can simply run:
 ```bash
-apt install bat
+sudo apt install bat
 ```
-If you install `bat` this way, please note that the executable may be installed as `batcat` instead of `bat` (due to [a name
+**Important**: If you install `bat` this way, please note that the executable may be installed as `batcat` instead of `bat` (due to [a name
 clash with another package](https://github.com/sharkdp/bat/issues/982)). You can set up a `bat -> batcat` symlink or alias to prevent any issues that may come up because of this and to be consistent with other distributions:
 ``` bash
 mkdir -p ~/.local/bin
@@ -211,7 +282,7 @@ the most recent release of `bat`, download the latest `.deb` package from the
 [release page](https://github.com/sharkdp/bat/releases) and install it via:
 ```bash
-sudo dpkg -i bat_0.17.1_amd64.deb  # adapt version number and architecture
+sudo dpkg -i bat_0.18.3_amd64.deb  # adapt version number and architecture
 ```
 ### On Alpine Linux
@@ -240,6 +311,14 @@ You can install [the `bat` package](https://koji.fedoraproject.org/koji/packagei
 dnf install bat
 ```
 ### On Funtoo Linux
 You can install [the `bat` package](https://github.com/funtoo/dev-kit/tree/1.4-release/sys-apps/bat) from dev-kit.
 ```bash
 emerge sys-apps/bat
 ```
 ### On Gentoo Linux
 You can install [the `bat` package](https://packages.gentoo.org/packages/sys-apps/bat)
@@ -256,6 +335,13 @@ You can install `bat` via xbps-install:
 xbps-install -S bat
 ```
 ### On Termux
 You can install `bat` via pkg:
 ```bash
 pkg install bat
 ```
 ### On FreeBSD
 You can install a precompiled [`bat` package](https://www.freshports.org/textproc/bat) with pkg:
@@ -271,6 +357,14 @@ cd /usr/ports/textproc/bat
 make install
 ```
 ### On OpenBSD
 You can install `bat` package using [`pkg_add(1)`](https://man.openbsd.org/pkg_add.1):
 ```bash
 pkg_add bat
 ```
 ### Via nix
 You can install `bat` using the [nix package manager](https://nixos.org/nix):
@@ -287,9 +381,14 @@ You can install `bat` with zypper:
 zypper install bat
 ```
 ### Via snap package
 There is currently no recommended snap package available.
 Existing packages may be available, but are not officially supported and may contain [issues](https://github.com/sharkdp/bat/issues/1519).
 ### On macOS (or Linux) via Homebrew
-You can install `bat` with [Homebrew on MacOS](https://formulae.brew.sh/formula/bat) or [Homebrew on Linux](https://formulae.brew.sh/formula-linux/bat):
+You can install `bat` with [Homebrew](https://formulae.brew.sh/formula/bat):
 ```bash
 brew install bat
@@ -312,6 +411,14 @@ take a look at the ["Using `bat` on Windows"](#using-bat-on-windows) section.
 You will need to install the [Visual C++ Redistributable](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads) package.
 #### With WinGet
 You can install `bat` via [WinGet](https://learn.microsoft.com/en-us/windows/package-manager/winget):
 ```bash
 winget install sharkdp.bat
 ```
 #### With Chocolatey
 You can install `bat` via [Chocolatey](https://chocolatey.org/packages/Bat):
@@ -340,7 +447,7 @@ binaries are also available: look for archives with `musl` in the file name.
 ### From source
-If you want to build `bat` from source, you need Rust 1.40 or
+If you want to build `bat` from source, you need Rust 1.70.0 or
 higher. You can then use `cargo` to build everything:
 ```bash
@@ -374,12 +481,11 @@ You can also use a custom theme by following the
 ### 8-bit themes
-`bat` has four themes that always use [8-bit colors](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors),
+`bat` has three themes that always use [8-bit colors](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors),
 even when truecolor support is available:
- `ansi-dark` looks decent on any terminal with a dark background. It uses 3-bit colors: black, red,
+- `ansi` looks decent on any terminal. It uses 3-bit colors: black, red, green,
-  green, yellow, blue, magenta, cyan, and white.
+  yellow, blue, magenta, cyan, and white.
 - `ansi-light` is like `ansi-dark`, but for terminals with a light background.
 - `base16` is designed for [base16](https://github.com/chriskempson/base16) terminal themes. It uses
  4-bit colors (3-bit colors plus bright variants) in accordance with the
  [base16 styling guidelines](https://github.com/chriskempson/base16/blob/master/styling.md).
@@ -387,10 +493,11 @@ even when truecolor support is available:
  It replaces certain bright colors with 8-bit colors from 16 to 21. **Do not** use this simply
  because you have a 256-color terminal but are not using base16-shell.
-Although these themes are more restricted, they have two advantages over truecolor themes:
+Although these themes are more restricted, they have three advantages over truecolor themes. They:
- They harmonize better with other terminal software using 3-bit or 4-bit colors.
+- Enjoy maximum compatibility. Some terminal utilities do not support more than 3-bit colors.
- When you change your terminal theme, `bat` output already on the screen will update to match.
+- Adapt to terminal theme changes. Even for already printed output.
 - Visually harmonize better with other terminal software.
 ### Output style
@@ -466,10 +573,11 @@ You can add new (or change existing) file name patterns using the `--map-syntax`
 command line option. The option takes an argument of the form `pattern:syntax` where
 `pattern` is a glob pattern that is matched against the file name and
 the absolute file path. The `syntax` part is the full name of a supported language
-(use `bat --list-languages` for an overview)full .
+(use `bat --list-languages` for an overview).
-Note: You probably want to use this option as an entry in `bat`s configuration file instead
+**Note:** You probably want to use this option as [an entry in `bat`'s configuration file](#configuration-file)
-of passing it on the command line (see below).
+for persistence instead of passing it on the command line as a one-off. Generally
 you'd just use `-l` if you want to manually specify a language for a file.
 Example: To use "INI" syntax highlighting for all files with a `.conf` file extension, use
 ```bash
@@ -484,7 +592,7 @@ Example: To open all files called `.ignore` (exact match) with the "Git Ignore"
 Example: To open all `.conf` files in subfolders of `/etc/apache2` with the "Apache Conf"
 syntax, use (this mapping is already built in):
 ```bash
-map-syntax='/etc/apache2/**/*.conf:Apache Conf'
+--map-syntax='/etc/apache2/**/*.conf:Apache Conf'
 ```
 ### Using a different pager
@@ -494,6 +602,8 @@ set, `less` is used by default. If you want to use a different pager, you can ei
 `PAGER` variable or set the `BAT_PAGER` environment variable to override what is specified in
 `PAGER`.
 **Note**: If `PAGER` is `more` or `most`, `bat` will silently use `less` instead to ensure support for colors.
 If you want to pass command-line arguments to the pager, you can also set them via the
 `PAGER`/`BAT_PAGER` variables:
@@ -543,7 +653,7 @@ alias cat="bat --theme=\$(defaults read -globalDomain AppleInterfaceStyle &> /de
 `bat` can also be customized with a configuration file. The location of the file is dependent
 on your operating system. To get the default path for your system, call
-```
+```bash
 bat --config-file
 ```
@@ -558,6 +668,10 @@ A default configuration file can be created with the `--generate-config-file` op
 bat --generate-config-file
 ```
 There is also now a systemwide configuration file, which is located under `/etc/bat/config` on
 Linux and Mac OS and `C:\ProgramData\bat\config` on windows. If the system wide configuration
 file is present, the content of the user configuration will simply be appended to it.
 ### Format
 The configuration file is a simple list of command line arguments. Use `bat --help` to see a full list of possible options and values. In addition, you can add comments by prepending a line with the `#` character.
@@ -573,7 +687,7 @@ Example configuration file:
 # Use italic text on the terminal (not supported on all terminals)
 --italic-text=always
-# Use C++ syntax for .ino files
+# Use C++ syntax for Arduino .ino files
 --map-syntax "*.ino:C++"
 ```
@@ -599,9 +713,7 @@ Windows 10 natively supports colors in both `conhost.exe` (Command Prompt) and P
 well as in newer versions of bash. On earlier versions of Windows, you can use
 [Cmder](http://cmder.net/), which includes [ConEmu](https://conemu.github.io/).
-**Note:** The Git and MSYS versions of `less` do not correctly interpret colors on Windows. If you
+**Note:** Old versions of `less` do not correctly interpret colors on Windows. To fix this, you can add the optional Unix tools to your PATH when installing Git. If you don’t have any other pagers installed, you can disable paging entirely by passing `--paging=never` or by setting `BAT_PAGER` to an empty string.
 don’t have any other pagers installed, you can disable paging entirely by passing `--paging=never`
 or by setting `BAT_PAGER` to an empty string.
 ### Cygwin
@@ -625,6 +737,13 @@ bat() {
 ## Troubleshooting
 ### Garbled output
 If an input file contains color codes or other ANSI escape sequences or control characters, `bat` will have problems
 performing syntax highlighting and text wrapping, and thus the output can become garbled.
 When displaying such files it is recommended to disable both syntax highlighting and wrapping by
 passing the `--color=never --wrap=never` options to `bat`.
 ### Terminals & colors
 `bat` handles terminals *with* and *without* truecolor support. However, the colors in most syntax
@@ -676,6 +795,11 @@ bash assets/create.sh
 cargo install --path . --locked --force
 ```
 If you want to build an application that uses `bat`s pretty-printing
 features as a library, check out the [the API documentation](https://docs.rs/bat/).
 Note that you have to use either `regex-onig` or `regex-fancy` as a feature
 when you depend on `bat` as a library.
 ## Contributing
 Take a look at the [`CONTRIBUTING.md`](CONTRIBUTING.md) guide.
@@ -685,6 +809,11 @@ Take a look at the [`CONTRIBUTING.md`](CONTRIBUTING.md) guide.
 - [sharkdp](https://github.com/sharkdp)
 - [eth-p](https://github.com/eth-p)
 - [keith-hall](https://github.com/keith-hall)
 - [Enselic](https://github.com/Enselic)
 ## Security vulnerabilities
 Please contact [David Peter](https://david-peter.de/) via email if you want to report a vulnerability in `bat`.
 ## Project goals and alternatives
@@ -699,7 +828,7 @@ There are a lot of alternatives, if you are looking for similar programs. See
 [this document](doc/alternatives.md) for a comparison.
 ## License
-Copyright (c) 2018-2020 [bat-developers](https://github.com/sharkdp/bat).
+Copyright (c) 2018-2023 [bat-developers](https://github.com/sharkdp/bat).
 `bat` is made available under the terms of either the MIT License or the Apache License 2.0, at your option.
@@ -0,0 +1,95 @@
 using namespace System.Management.Automation
 using namespace System.Management.Automation.Language
 Register-ArgumentCompleter -Native -CommandName '{{PROJECT_EXECUTABLE}}' -ScriptBlock {
    param($wordToComplete, $commandAst, $cursorPosition)
    $commandElements = $commandAst.CommandElements
    $command = @(
        '{{PROJECT_EXECUTABLE}}'
        for ($i = 1; $i -lt $commandElements.Count; $i++) {
            $element = $commandElements[$i]
            if ($element -isnot [StringConstantExpressionAst] -or
                $element.StringConstantType -ne [StringConstantType]::BareWord -or
                $element.Value.StartsWith('-')) {
                break
        }
        $element.Value
    }) -join ';'
    $completions = @(switch ($command) {
        '{{PROJECT_EXECUTABLE}}' {
            [CompletionResult]::new('-l', 'l', [CompletionResultType]::ParameterName, 'Set the language for syntax highlighting.')
            [CompletionResult]::new('--language', 'language', [CompletionResultType]::ParameterName, 'Set the language for syntax highlighting.')
            [CompletionResult]::new('-H', 'H', [CompletionResultType]::ParameterName, 'Highlight lines N through M.')
            [CompletionResult]::new('--highlight-line', 'highlight-line', [CompletionResultType]::ParameterName, 'Highlight lines N through M.')
            [CompletionResult]::new('--file-name', 'file-name', [CompletionResultType]::ParameterName, 'Specify the name to display for a file.')
            [CompletionResult]::new('--diff-context', 'diff-context', [CompletionResultType]::ParameterName, 'diff-context')
            [CompletionResult]::new('--tabs', 'tabs', [CompletionResultType]::ParameterName, 'Set the tab width to T spaces.')
            [CompletionResult]::new('--wrap', 'wrap', [CompletionResultType]::ParameterName, 'Specify the text-wrapping mode (*auto*, never, character).')
            [CompletionResult]::new('--terminal-width', 'terminal-width', [CompletionResultType]::ParameterName, 'Explicitly set the width of the terminal instead of determining it automatically. If prefixed with ''+'' or ''-'', the value will be treated as an offset to the actual terminal width. See also: ''--wrap''.')
            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'When to use colors (*auto*, never, always).')
            [CompletionResult]::new('--italic-text', 'italic-text', [CompletionResultType]::ParameterName, 'Use italics in output (always, *never*)')
            [CompletionResult]::new('--decorations', 'decorations', [CompletionResultType]::ParameterName, 'When to show the decorations (*auto*, never, always).')
            [CompletionResult]::new('--paging', 'paging', [CompletionResultType]::ParameterName, 'Specify when to use the pager, or use `-P` to disable (*auto*, never, always).')
            [CompletionResult]::new('--pager', 'pager', [CompletionResultType]::ParameterName, 'Determine which pager to use.')
            [CompletionResult]::new('-m', 'm', [CompletionResultType]::ParameterName, 'Use the specified syntax for files matching the glob pattern (''*.cpp:C++'').')
            [CompletionResult]::new('--map-syntax', 'map-syntax', [CompletionResultType]::ParameterName, 'Use the specified syntax for files matching the glob pattern (''*.cpp:C++'').')
            [CompletionResult]::new('--theme', 'theme', [CompletionResultType]::ParameterName, 'Set the color theme for syntax highlighting.')
            [CompletionResult]::new('--style', 'style', [CompletionResultType]::ParameterName, 'Comma-separated list of style elements to display (*default*, auto, full, plain, changes, header, header-filename, header-filesize, grid, rule, numbers, snip).')
            [CompletionResult]::new('-r', 'r', [CompletionResultType]::ParameterName, 'Only print the lines from N to M.')
            [CompletionResult]::new('--line-range', 'line-range', [CompletionResultType]::ParameterName, 'Only print the lines from N to M.')
            [CompletionResult]::new('-A', 'A', [CompletionResultType]::ParameterName, 'Show non-printable characters (space, tab, newline, ..).')
            [CompletionResult]::new('--show-all', 'show-all', [CompletionResultType]::ParameterName, 'Show non-printable characters (space, tab, newline, ..).')
            [CompletionResult]::new('-p', 'p', [CompletionResultType]::ParameterName, 'Show plain style (alias for ''--style=plain'').')
            [CompletionResult]::new('--plain', 'plain', [CompletionResultType]::ParameterName, 'Show plain style (alias for ''--style=plain'').')
            [CompletionResult]::new('-d', 'd', [CompletionResultType]::ParameterName, 'Only show lines that have been added/removed/modified.')
            [CompletionResult]::new('--diff', 'diff', [CompletionResultType]::ParameterName, 'Only show lines that have been added/removed/modified.')
            [CompletionResult]::new('-n', 'n', [CompletionResultType]::ParameterName, 'Show line numbers (alias for ''--style=numbers'').')
            [CompletionResult]::new('--number', 'number', [CompletionResultType]::ParameterName, 'Show line numbers (alias for ''--style=numbers'').')
            [CompletionResult]::new('-f', 'f', [CompletionResultType]::ParameterName, 'f')
            [CompletionResult]::new('--force-colorization', 'force-colorization', [CompletionResultType]::ParameterName, 'force-colorization')
            [CompletionResult]::new('-P', 'P', [CompletionResultType]::ParameterName, 'Alias for ''--paging=never''')
            [CompletionResult]::new('--no-paging', 'no-paging', [CompletionResultType]::ParameterName, 'Alias for ''--paging=never''')
            [CompletionResult]::new('--list-themes', 'list-themes', [CompletionResultType]::ParameterName, 'Display all supported highlighting themes.')
            [CompletionResult]::new('-L', 'L', [CompletionResultType]::ParameterName, 'Display all supported languages.')
            [CompletionResult]::new('--list-languages', 'list-languages', [CompletionResultType]::ParameterName, 'Display all supported languages.')
            [CompletionResult]::new('-u', 'u', [CompletionResultType]::ParameterName, 'u')
            [CompletionResult]::new('--unbuffered', 'unbuffered', [CompletionResultType]::ParameterName, 'unbuffered')
            [CompletionResult]::new('--no-config', 'no-config', [CompletionResultType]::ParameterName, 'Do not use the configuration file')
            [CompletionResult]::new('--no-custom-assets', 'no-custom-assets', [CompletionResultType]::ParameterName, 'Do not load custom assets')
            [CompletionResult]::new('--lessopen', 'lessopen', [CompletionResultType]::ParameterName, 'Enable the $LESSOPEN preprocessor')
            [CompletionResult]::new('--no-lessopen', 'no-lessopen', [CompletionResultType]::ParameterName, 'Disable the $LESSOPEN preprocessor if enabled (overrides --lessopen)')
            [CompletionResult]::new('--config-file', 'config-file', [CompletionResultType]::ParameterName, 'Show path to the configuration file.')
            [CompletionResult]::new('--generate-config-file', 'generate-config-file', [CompletionResultType]::ParameterName, 'Generates a default configuration file.')
            [CompletionResult]::new('--config-dir', 'config-dir', [CompletionResultType]::ParameterName, 'Show bat''s configuration directory.')
            [CompletionResult]::new('--cache-dir', 'cache-dir', [CompletionResultType]::ParameterName, 'Show bat''s cache directory.')
            [CompletionResult]::new('--diagnostic', 'diagnostic', [CompletionResultType]::ParameterName, 'Show diagnostic information for bug reports.')
            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print this help message.')
            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print this help message.')
            [CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Show version information.')
            [CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Show version information.')
            ## Completion of the 'cache' command itself is removed for better UX
            ## See https://github.com/sharkdp/bat/issues/2085#issuecomment-1271646802
            break
        }
        '{{PROJECT_EXECUTABLE}};cache' {
            [CompletionResult]::new('--source', 'source', [CompletionResultType]::ParameterName, 'Use a different directory to load syntaxes and themes from.')
            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'Use a different directory to store the cached syntax and theme set.')
            [CompletionResult]::new('-b', 'b', [CompletionResultType]::ParameterName, 'Initialize (or update) the syntax/theme cache.')
            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'Initialize (or update) the syntax/theme cache.')
            [CompletionResult]::new('-c', 'c', [CompletionResultType]::ParameterName, 'Remove the cached syntax definitions and themes.')
            [CompletionResult]::new('--clear', 'clear', [CompletionResultType]::ParameterName, 'Remove the cached syntax definitions and themes.')
            [CompletionResult]::new('--blank', 'blank', [CompletionResultType]::ParameterName, 'Create completely new syntax and theme sets (instead of appending to the default sets).')
            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Prints help information')
            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Prints help information')
            [CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Prints version information')
            [CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Prints version information')
            break
        }
    })
    $completions.Where{ $_.CompletionText -like "$wordToComplete*" } |
        Sort-Object -Property ListItemText
 }
@@ -0,0 +1,192 @@
 # shellcheck disable=SC2207
 # Requires https://github.com/scop/bash-completion
 # Macs have bash3 for which the bash-completion package doesn't include
 # _init_completion. This is a minimal version of that function.
 __bat_init_completion()
 {
 	COMPREPLY=()
 	_get_comp_words_by_ref "$@" cur prev words cword
 }
 __bat_escape_completions()
 {
 	# Do not escape if completing a quoted value.
 	[[ $cur == [\"\']* ]] && return 0
 	# printf -v to an array index is available in bash >= 4.1.
 	# Use it if available, as -o filenames is semantically incorrect if
 	# we are not actually completing filenames, and it has side effects
 	# (e.g. adds trailing slash to candidates matching present dirs).
 	if ((
 		BASH_VERSINFO[0] > 4 || \
 		BASH_VERSINFO[0] == 4 && BASH_VERSINFO[1] > 0
 	)); then
 		local i
 		for i in ${!COMPREPLY[*]}; do
 			printf -v "COMPREPLY[i]" %q "${COMPREPLY[i]}"
 		done
 	else
 		compopt -o filenames
 	fi
 }
 _bat() {
 	local cur prev words split=false
 	if declare -F _init_completion >/dev/null 2>&1; then
 		_init_completion -s || return 0
 	else
 		__bat_init_completion -n "=" || return 0
 		_split_longopt && split=true
 	fi
 	if [[ ${words[1]-} == cache ]]; then
 		case $prev in
 		--source | --target)
 			_filedir -d
 			return 0
 			;;
 		esac
 		COMPREPLY=($(compgen -W "
 			--build
 			--clear
 			--source
 			--target
 			--blank
 			--help
 		" -- "$cur"))
 		return 0
 	fi
 	case $prev in
 	-l | --language)
 		local IFS=$'\n'
 		COMPREPLY=($(compgen -W "$(
 			"$1" --list-languages | while IFS=: read -r lang _; do
 				printf "%s\n" "$lang"
 			done
 		)" -- "$cur"))
                __bat_escape_completions
 		return 0
 		;;
 	-H | --highlight-line | \
 	--diff-context | \
 	--tabs | \
 	--terminal-width | \
 	-m | --map-syntax | \
 	--ignored-suffix | \
 	--list-themes | \
 	--line-range | \
 	-L | --list-languages | \
 	--lessopen | \
 	--diagnostic | \
 	--acknowledgements | \
 	-h | --help | \
 	-V | --version | \
 	--cache-dir | \
 	--config-dir | \
 	--config-file | \
 	--generate-config-file)
 		# argument required but no completion available, or option
 		# causes an exit
 		return 0
 		;;
 	--file-name)
 		_filedir
 		return 0
 		;;
 	--wrap)
 		COMPREPLY=($(compgen -W "auto never character" -- "$cur"))
 		return 0
 		;;
 	--color | --decorations | --paging)
 		COMPREPLY=($(compgen -W "auto never always" -- "$cur"))
 		return 0
 		;;
 	--italic-text)
 		COMPREPLY=($(compgen -W "always never" -- "$cur"))
 		return 0
 		;;
 	--pager)
 		COMPREPLY=($(compgen -c -- "$cur"))
 		return 0
 		;;
 	--theme)
 		local IFS=$'\n'
 		COMPREPLY=($(compgen -W "$("$1" --list-themes)" -- "$cur"))
                __bat_escape_completions
 		return 0
 		;;
 	--style)
 		# shellcheck disable=SC2034
 		local -a styles=(
 			default
 			full
 			auto
 			plain
 			changes
 			header
 			header-filename
 			header-filesize
 			grid
 			rule
 			numbers
 			snip
 		)
                # shellcheck disable=SC2016
 		if declare -F _comp_delimited >/dev/null 2>&1; then
 			# bash-completion > 2.11
 			_comp_delimited , -W '"${styles[@]}"'
 		else
 			COMPREPLY=($(compgen -W '${styles[@]}' -- "$cur"))
 		fi
 		return 0
 	esac
 	$split && return 0
 	if [[ $cur == -* ]]; then
 		# --unbuffered excluded intentionally (no-op)
 		COMPREPLY=($(compgen -W "
 			--show-all
 			--plain
 			--language
 			--highlight-line
 			--file-name
 			--diff
 			--diff-context
 			--tabs
 			--wrap
 			--terminal-width
 			--number
 			--color
 			--italic-text
 			--decorations
 			--force-colorization
 			--paging
 			--pager
 			--map-syntax
 			--ignored-suffix
 			--theme
 			--list-themes
 			--style
 			--line-range
 			--list-languages
 			--lessopen
 			--diagnostic
 			--acknowledgements
 			--help
 			--version
 			--cache-dir
 			--config-dir
 			--config-file
 			--generate-config-file
 		" -- "$cur"))
 		return 0
 	fi
 	_filedir
 	## Completion of the 'cache' command itself is removed for better UX
 	## See https://github.com/sharkdp/bat/issues/2085#issuecomment-1271646802
 } && complete -F _bat {{PROJECT_EXECUTABLE}}
@@ -1,78 +1,222 @@
 # Fish Shell Completions
-# Place or symlink to $XDG_CONFIG_HOME/fish/completions/{{PROJECT_EXECUTABLE}}.fish ($XDG_CONFIG_HOME is usually set to ~/.config)
+# Copy or symlink to $XDG_CONFIG_HOME/fish/completions/{{PROJECT_EXECUTABLE}}.fish
 # ($XDG_CONFIG_HOME is usually set to ~/.config)
-# Helper function:
+# `bat` is `batcat` on Debian and Ubuntu
-function __{{PROJECT_EXECUTABLE}}_autocomplete_languages --description "A helper function used by "(status filename)
+set bat {{PROJECT_EXECUTABLE}}
 	{{PROJECT_EXECUTABLE}} --list-languages | awk -F':' '
 		{
 			lang=$1
 			split($2, exts, ",")
-			for (i in exts) {
+# Helper functions:
-				ext=exts[i]
+
-				if (ext !~ /[A-Z].*/ && ext !~ /^\..*rc$/) {
+function __bat_complete_files -a token
-					print ext"\t"lang
+    # Cheat to complete files by calling `complete -C` on a fake command name,
-				}
+    # like `__fish_complete_directories` does.
-			}
+    set -l fake_command aaabccccdeeeeefffffffffgghhhhhhiiiii
-		}
+    complete -C"$fake_command $token"
 	' | sort
 end
 function __bat_complete_one_language -a comp
    command $bat --list-languages | string split -f1 : | string match -e "$comp"
 end
 function __bat_complete_list_languages
    for spec in (command $bat --list-languages)
        set -l name (string split -f1 : $spec)
        for ext in (string split -f2 : $spec | string split ,)
            test -n "$ext"; or continue
            string match -rq '[/*]' $ext; and continue
            printf "%s\t%s\n" $ext $name
        end
        printf "%s\t\n" $name
    end
 end
 function __bat_complete_map_syntax
    set -l token (commandline -ct)
    if string match -qr '(?<glob>.+):(?<syntax>.*)' -- $token
        # If token ends with a colon, complete with the list of language names.
        set -f comps $glob:(__bat_complete_one_language $syntax)
    else if string match -qr '\*' -- $token
        # If token contains a globbing character (`*`), complete only possible
        # globs in the current directory
        set -f comps (__bat_complete_files $token | string match -er '[*]'):
    else
        # Complete files (and globs).
        set -f comps (__bat_complete_files $token | string match -erv '/$'):
    end
    if set -q comps[1]
        printf "%s\t\n" $comps
    end
 end
 function __bat_cache_subcommand
    __fish_seen_subcommand_from cache
 end
 # Returns true if no exclusive arguments seen.
 function __bat_no_excl_args
    not __bat_cache_subcommand; and not __fish_seen_argument \
        -s h -l help \
        -s V -l version \
        -l acknowledgements \
        -l config-dir -l config-file \
        -l diagnostic \
        -l list-languages -l list-themes
 end
 # Returns true if the 'cache' subcommand is seen without any exclusive arguments.
 function __bat_cache_no_excl
    __bat_cache_subcommand; and not __fish_seen_argument \
        -s h -l help \
        -l acknowledgements -l build -l clear
 end
 function __bat_style_opts
    set -l style_opts \
        "default,recommended components" \
        "auto,same as 'default' unless piped" \
        "full,all components" \
        "plain,no components" \
        "changes,Git change markers" \
        "header,alias for header-filename" \
        "header-filename,filename above content" \
        "header-filesize,filesize above content" \
        "grid,lines b/w sidebar/header/content" \
        "numbers,line numbers in sidebar" \
        "rule,separate files" \
        "snip,separate ranges"
    string replace , \t $style_opts
 end
 # Use option argument descriptions to indicate which is the default, saving
 # horizontal space and making sure the option description isn't truncated.
 set -l color_opts '
    auto\tdefault
    never\t
    always\t
 '
 set -l decorations_opts $color_opts
 set -l paging_opts $color_opts
 # Include some examples so we can indicate the default.
 set -l pager_opts '
    less\tdefault
    less\ -FR\t
    more\t
    vimpager\t
 '
 set -l italic_text_opts '
    always\t
    never\tdefault
 '
 set -l wrap_opts '
    auto\tdefault
    never\t
    character\t
 '
 # While --tabs theoretically takes any number, most people should be OK with these.
 # Specifying a list lets us explain what 0 does.
 set -l tabs_opts '
    0\tpass\ tabs\ through\ directly
    1\t
    2\t
    4\t
    8\t
 '
 # Completions:
-complete -c {{PROJECT_EXECUTABLE}} -l color -xka "auto never always" -d "Specify when to use colored output (default: auto)" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l acknowledgements -d "Print acknowledgements" -n __fish_is_first_arg
-complete -c {{PROJECT_EXECUTABLE}} -l config-dir -d "Display location of '{{PROJECT_EXECUTABLE}}' configuration directory" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l color -x -a "$color_opts" -d "When to use colored output" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -l config-file -d "Display location of '{{PROJECT_EXECUTABLE}}' configuration file" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l config-dir -f -d "Display location of configuration directory" -n __fish_is_first_arg
-complete -c {{PROJECT_EXECUTABLE}} -l decorations -xka "auto never always" -d "Specify when to use the decorations specified with '--style' (default: auto)" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l config-file -f -d "Display location of configuration file" -n __fish_is_first_arg
-complete -c {{PROJECT_EXECUTABLE}} -s h -l help -d "Print help message" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l decorations -x -a "$decorations_opts" -d "When to use --style decorations" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -s H -l highlight-line -x -d "<N> Highlight the N-th line with a different background color" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l diagnostic -d "Print diagnostic info for bug reports" -n __fish_is_first_arg
-complete -c {{PROJECT_EXECUTABLE}} -l italic-text -xka "always never" -d "Specify when to use ANSI sequences for italic text (default: never)" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -s d -l diff -d "Only show lines with Git changes" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -s l -l language -d "Set the language for syntax highlighting" -n "not __fish_seen_subcommand_from cache" -xa "(__{{PROJECT_EXECUTABLE}}_autocomplete_languages)" 
+complete -c $bat -l diff-context -x -d "Show N context lines around Git changes" -n "__fish_seen_argument -s d -l diff"
-complete -c {{PROJECT_EXECUTABLE}} -s r -l line-range -x -d "<N:M> Only print the specified range of lines for each file" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l file-name -x -d "Specify the display name" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -l list-languages -d "Display list of supported languages for syntax highlighting" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -s f -l force-colorization -d "Force color and decorations" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -l list-themes -d "Display a list of supported themes for syntax highlighting" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -s h -d "Print a concise overview" -n __fish_is_first_arg
-complete -c {{PROJECT_EXECUTABLE}} -s m -l map-syntax -x -d "<from:to> Map a file extension or file name to an existing syntax" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l help -f -d "Print all help information" -n __fish_is_first_arg
-complete -c {{PROJECT_EXECUTABLE}} -s n -l number -d "Only show line numbers, no other decorations. Alias for '--style=numbers'" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -s H -l highlight-line -x -d "Highlight line(s) N[:M]" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -l pager -x -d "<command> Specify which pager program to use (default: less)" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l ignored-suffix -x -d "Ignore extension" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -l paging -xka "auto never always" -d "Specify when to use the pager (default: auto)" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l italic-text -x -a "$italic_text_opts" -d "When to use italic text in the output" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -s p -l plain -d "Only show plain style, no decorations. Alias for '--style=plain'" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -s l -l language -x -k -a "(__bat_complete_list_languages)" -d "Set the syntax highlighting language" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -s P -d "Disable paging. Alias for '--paging=never'" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l lessopen -d "Enable the $LESSOPEN preprocessor" -n __fish_is_first_arg
-complete -c {{PROJECT_EXECUTABLE}} -s A -l show-all -d "Show non-printable characters like space/tab/newline" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -s r -l line-range -x -d "Only print lines [M]:[N] (either optional)" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -l style -xka "auto full plain changes header grid numbers" -d "Comma-separated list of style elements or presets to display with file contents" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l list-languages -f -d "List syntax highlighting languages" -n __fish_is_first_arg
-complete -c {{PROJECT_EXECUTABLE}} -l tabs -x -d "<T> Set the tab width to T spaces (width of 0 passes tabs through directly)" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l list-themes -f -d "List syntax highlighting themes" -n __fish_is_first_arg
-complete -c {{PROJECT_EXECUTABLE}} -l terminal-width -x -d "<width> Explicitly set terminal width; Prefix with '+' or '-' to offset (default width is auto determined)" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -s m -l map-syntax -x -a "(__bat_complete_map_syntax)" -d "Map <glob pattern>:<language syntax>" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -l theme -xka "({{PROJECT_EXECUTABLE}} --list-themes | cat)" -d "Set the theme for syntax highlighting" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -s n -l number -d "Only show line numbers, no other decorations" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -s u -l unbuffered -d "POSIX-compliant unbuffered output. Option is ignored" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l pager -x -a "$pager_opts" -d "Which pager to use" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -s V -l version -d "Show version information" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l paging -x -a "$paging_opts" -d "When to use the pager" -n __bat_no_excl_args
-complete -c {{PROJECT_EXECUTABLE}} -l wrap -xka "auto never character" -d "<mode> Specify the text-wrapping mode (default: auto)" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -s p -l plain -d "Disable decorations" -n __bat_no_excl_args
 complete -c $bat -o pp -d "Disable decorations and paging" -n __bat_no_excl_args
 complete -c $bat -s P -d "Disable paging" -n __bat_no_excl_args
 complete -c $bat -s A -l show-all -d "Show non-printable characters" -n __bat_no_excl_args
 complete -c $bat -l style -x -k -a "(__fish_complete_list , __bat_style_opts)" -d "Specify which non-content elements to display" -n __bat_no_excl_args
 complete -c $bat -l tabs -x -a "$tabs_opts" -d "Set tab width" -n __bat_no_excl_args
 complete -c $bat -l terminal-width -x -d "Set terminal <width>, +<offset>, or -<offset>" -n __bat_no_excl_args
 complete -c $bat -l theme -x -a "(command $bat --list-themes | command cat)" -d "Set the syntax highlighting theme" -n __bat_no_excl_args
 complete -c $bat -s V -l version -f -d "Show version information" -n __fish_is_first_arg
 complete -c $bat -l wrap -x -a "$wrap_opts" -d "Text-wrapping mode" -n __bat_no_excl_args
 # Sub-command 'cache' completions
-complete -c {{PROJECT_EXECUTABLE}} -a "cache" -d "Modify the syntax/language definition cache" -n "not __fish_seen_subcommand_from cache"
+## Completion of the 'cache' command itself is removed for better UX
 ## See https://github.com/sharkdp/bat/issues/2085#issuecomment-1271646802
-complete -c {{PROJECT_EXECUTABLE}} -l build -f -d "Parse syntaxes/language definitions into cache" -n "__fish_seen_subcommand_from cache"
+complete -c $bat -l build -f -d "Parse new definitions into cache" -n __bat_cache_no_excl
-complete -c {{PROJECT_EXECUTABLE}} -l clear -f -d "Reset syntaxes/language definitions to default settings" -n "__fish_seen_subcommand_from cache"
+complete -c $bat -l clear -f -d "Reset definitions to defaults" -n __bat_cache_no_excl
 complete -c $bat -l blank -f -d "Create new data instead of appending" -n "__bat_cache_subcommand; and not __fish_seen_argument -l clear"
 complete -c $bat -l source -x -a "(__fish_complete_directories)" -d "Load syntaxes and themes from DIR" -n "__bat_cache_subcommand; and not __fish_seen_argument -l clear"
 complete -c $bat -l target -x -a "(__fish_complete_directories)" -d "Store cache in DIR" -n __bat_cache_subcommand
 complete -c $bat -l acknowledgements -d "Build acknowledgements.bin" -n __bat_cache_no_excl
 complete -c $bat -s h -d "Print a concise overview of $bat-cache help" -n __bat_cache_no_excl
 complete -c $bat -l help -f -d "Print all $bat-cache help" -n __bat_cache_no_excl
 # vim:ft=fish
@@ -44,6 +44,14 @@ _{{PROJECT_EXECUTABLE}}_main() {
        '(--style)'--style='[Comma-separated list of style elements to display]:<components>:->style'
        '(-r --line-range)'{-r+,--line-range=}'[Only print the lines from N to M]:<N\:M>...'
        '(: --list-themes --list-languages -L)'{-L,--list-languages}'[Display all supported languages]'
        '(: --no-config)'--no-config'[Do not use the configuration file]'
        '(: --no-custom-assets)'--no-custom-assets'[Do not load custom assets]'
        '(: --lessopen)'--lessopen'[Enable the $LESSOPEN preprocessor]'
        '(: --no-lessopen)'--no-lessopen'[Disable the $LESSOPEN preprocessor if enabled (overrides --lessopen)]'
        '(: --config-dir)'--config-dir'[Show bat'"'"'s configuration directory]'
        '(: --config-file)'--config-file'[Show path to the configuration file]'
        '(: --generate-config-file)'--generate-config-file'[Generates a default configuration file]'
        '(: --cache-dir)'--cache-dir'[Show bat'"'"'s cache directory]'
        '(: -)'{-h,--help}'[Print this help message]'
        '(: -)'{-V,--version}'[Show version information]'
        '*: :_files'
@@ -69,25 +77,19 @@ _{{PROJECT_EXECUTABLE}}_main() {
        ;;
        style)
-            _values -s , 'style' auto full plain changes header grid numbers snip
+            _values -s , 'style' default auto full plain changes header header-filename header-filesize grid rule numbers snip
        ;;
    esac
 }
-# first positional argument
+case $words[2] in
-if (( ${#words} == 2 )); then
+    cache)
-    local -a subcommands
+        ## Completion of the 'cache' command itself is removed for better UX
-    subcommands=('cache:Modify the syntax-definition and theme cache')
+        ## See https://github.com/sharkdp/bat/issues/2085#issuecomment-1271646802
-    _describe subcommand subcommands
+        _{{PROJECT_EXECUTABLE}}_cache_subcommand
-    _{{PROJECT_EXECUTABLE}}_main
+    ;;
 else
    case $words[2] in
        cache)
            _{{PROJECT_EXECUTABLE}}_cache_subcommand
        ;;
-        *)
+    *)
-            _{{PROJECT_EXECUTABLE}}_main
+        _{{PROJECT_EXECUTABLE}}_main
-        ;;
+    ;;
-    esac
+esac
 fi
@@ -5,7 +5,7 @@ ASSET_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 REPO_DIR="$ASSET_DIR/.."
 # Ensure submodules are initialized.
-function update_submodules() {
+update_submodules() {
 	local submodule
 	local submodule_prompt=unspecified
 	local submodule_path
@@ -46,6 +46,7 @@ bat cache --clear
 # - Remove the JavaDoc patch once https://github.com/trishume/syntect/issues/222 has been fixed
 # - Remove the C# patch once https://github.com/sublimehq/Packages/pull/2331 has been merged
 # Apply patches
 (
    cd "$ASSET_DIR"
    for patch in patches/*.patch; do
@@ -53,11 +54,16 @@ bat cache --clear
    done
 )
-bat cache --build --blank --source="$ASSET_DIR" --target="$ASSET_DIR"
+reverse_patches() {
    (
        cd "$ASSET_DIR"
        for patch in patches/*.patch; do
            patch --strip=0 --reverse <"$patch"
        done
    )
 }
-(
+# Make sure to always reverse patches, even if the `bat cache` command fails or aborts
-    cd "$ASSET_DIR"
+trap reverse_patches EXIT
-    for patch in patches/*.patch; do
+
-        patch --strip=0 --reverse < "$patch"
+bat cache --build --blank --acknowledgements --source="$ASSET_DIR" --target="$ASSET_DIR"
    done
 )
@@ -25,11 +25,23 @@ either '--language value', '--language=value', '-l value' or '-lvalue'.
 Show non\-printable characters like space, tab or newline. Use '\-\-tabs' to
 control the width of the tab\-placeholders.
 .HP
 \fB\-\-nonprintable\-notation\fR <notation>
 .IP
 Specify how to display non-printable characters when using \-\-show\-all.
 Possible values:
 .RS
 .IP "caret"
 Use character sequences like ^G, ^J, ^@, .. to identify non-printable characters
 .IP "unicode"
 Use special Unicode code points to identify non-printable characters
 .RE
 .HP
 \fB\-p\fR, \fB\-\-plain\fR
 .IP
 Only show plain style, no decorations. This is an alias for
 \&'\-\-style=plain'. When '\-p' is used twice ('\-pp'), it also disables
-automatic paging (alias for '\-\-style=plain \fB\-\-pager\fR=\fI\,never\/\fR').
+automatic paging (alias for '\-\-style=plain \fB\-\-paging\fR=\fI\,never\/\fR').
 .HP
 \fB\-l\fR, \fB\-\-language\fR <language>
 .IP
@@ -40,7 +52,7 @@ language names and file extensions.
 .HP
 \fB\-H\fR, \fB\-\-highlight\-line\fR <N:M>...
 .IP
-Highlight the specified line ranges with a different background color For example:
+Highlight the specified line ranges with a different background color. For example:
 .RS
 .IP "\-\-highlight\-line 40"
 highlights line 40
@@ -50,8 +62,22 @@ highlights lines 30 to 40
 highlights lines 1 to 40
 .IP "\-\-highlight\-line 40:"
 highlights lines 40 to the end of the file
 .IP "\-\-highlight\-line 30:+10"
 highlights lines 30 to 40
 .RE
 .HP
 \fB\-\-file\-name\fR <name>...
 .IP
 Specify the name to display for a file. Useful when piping data to {{PROJECT_EXECUTABLE}} from STDIN when {{PROJECT_EXECUTABLE}} does not otherwise know the filename. Note that the provided file name is also used for syntax detection.
 .HP
 \fB\-d\fR, \fB\-\-diff\fR
 .IP
 Only show lines that have been added/removed/modified with respect to the Git index. Use '\-\-diff\-context=N' to control how much context you want to see.
 .HP
 \fB\-\-diff\-context\fR <N>...
 .IP
 Include N lines of context around added/removed/modified lines when using '\-\-diff'.
 .HP
 \fB\-\-tabs\fR <T>
 .IP
 Set the tab width to T spaces. Use a width of 0 to pass tabs through directly
@@ -104,6 +130,8 @@ which pager is used, see the '\-\-pager' option. Possible values: *auto*, never,
 Determine which pager is used. This option will override the PAGER and BAT_PAGER
 environment variables. The default pager is 'less'. To control when the pager is used, see
 the '\-\-paging' option. Example: '\-\-pager "less \fB\-RF\fR"'.
 Note: By default, if the pager is set to 'less' (and no command-line options are specified), 'bat' will pass the following command line options to the pager: '-R'/'--RAW-CONTROL-CHARS', '-F'/'--quit-if-one-screen' and '-X'/'--no-init'. The last option ('-X') is only used for 'less' versions older than 530. The '-R' option is needed to interpret ANSI colors correctly. The second option ('-F') instructs less to exit immediately if the output size is smaller than the vertical size of the terminal. This is convenient for small files because you do not have to press 'q' to quit the pager. The third option ('-X') is needed to fix a bug with the '--quit-if-one-screen' feature in old versions of 'less'. Unfortunately, it also breaks mouse-wheel support in 'less'. If you want to enable mouse-wheel scrolling on older versions of 'less', you can pass just '-R' (as in the example above, this will disable the quit-if-one-screen feature). For less 530 or newer, it should work out of the box.
 .HP
 \fB\-m\fR, \fB\-\-map\-syntax\fR <glob-pattern:syntax-name>...
 .IP
@@ -111,6 +139,7 @@ Map a glob pattern to an existing syntax name. The glob pattern is matched on th
 path and the filename. For example, to highlight *.build files with the Python syntax,
 use -m '*.build:Python'. To highlight files named '.myignore' with the Git Ignore
 syntax, use -m '.myignore:Git Ignore'.
 Note that the right-hand side is the *name* of the syntax, not a file extension.
 .HP
 \fB\-\-theme\fR <theme>
 .IP
@@ -129,7 +158,8 @@ Configure which elements (line numbers, file headers, grid borders, Git modifica
 of components to display (e.g. 'numbers,changes,grid') or a pre\-defined style ('full').
 To set a default style, add the '\-\-style=".."' option to the configuration file or
 export the BAT_STYLE environment variable (e.g.: export BAT_STYLE=".."). Possible
-values: *auto*, full, plain, changes, header, grid, rule, numbers, snip.
+values: *default*, full, auto, plain, changes, header, header-filename, header-filesize, grid,
 rule, numbers, snip.
 .HP
 \fB\-r\fR, \fB\-\-line\-range\fR <N:M>...
 .IP
@@ -141,6 +171,8 @@ prints lines 30 to 40
 prints lines 1 to 40
 .IP "\-\-line\-range 40:"
 prints lines 40 to the end of the file
 .IP "\-\-line\-range 30:+10"
 prints lines 30 to 40
 .RE
 .HP
 \fB\-L\fR, \fB\-\-list\-languages\fR
@@ -176,6 +208,10 @@ is dependent on your operating system. To get the default path for your system,
 Alternatively, you can use the BAT_CONFIG_PATH environment variable to point {{PROJECT_EXECUTABLE}} to a non-default
 location of the configuration file.
 To generate a default configuration file, call:
 \fB{{PROJECT_EXECUTABLE}} --generate-config-file\fR
 .SH "ADDING CUSTOM LANGUAGES"
 {{PROJECT_EXECUTABLE}} supports Sublime Text \fB.sublime-syntax\fR language files, and can be
 customized to add additional languages to your local installation. To do this, add the \fB.sublime-syntax\fR language
@@ -201,12 +237,29 @@ git clone https://github.com/tellnobody1/sublime-purescript-syntax
 Once the cache is built, the new language will be visible in `\fB{{PROJECT_EXECUTABLE}} --list-languages\fR`.
 .br
-If you ever want to remove the custom languages, you can clear the cache with `\fB{{PROJECT_EXECUTABLE}} cache --clear\fR`. 
+If you ever want to remove the custom languages, you can clear the cache with `\fB{{PROJECT_EXECUTABLE}} cache --clear\fR`.
 .SH "ADDING CUSTOM THEMES"
 Similarly to custom languages, {{PROJECT_EXECUTABLE}} supports Sublime Text \fB.tmTheme\fR themes.
 These can be installed to `\fB$({{PROJECT_EXECUTABLE}} --config-dir)/themes\fR`, and are added to the cache with
 `\fB{{PROJECT_EXECUTABLE}} cache --build`.
 .SH "INPUT PREPROCESSOR"
 Much like less(1) does, {{PROJECT_EXECUTABLE}} supports input preprocessors via the LESSOPEN and LESSCLOSE environment variables.
 In addition, {{PROJECT_EXECUTABLE}} attempts to be as compatible with less's preprocessor implementation as possible.
 To use the preprocessor, call:
 \fB{{PROJECT_EXECUTABLE}} --lessopen\fR
 Alternatively, the preprocessor may be enabled by default by adding the '\-\-lessopen' option to the configuration file. 
 To temporarily disable the preprocessor if it is enabled by default, call:
 \fB{{PROJECT_EXECUTABLE}} --no-lessopen\fR
 For more information, see the "INPUT PREPROCESSOR" section of less(1).  
 .SH "MORE INFORMATION"
 For more information and up-to-date documentation, visit the {{PROJECT_EXECUTABLE}} repo:
@@ -0,0 +1,16 @@
 diff --git syntaxes/02_Extra/Groff/Man Page/Man Page.sublime-syntax syntaxes/02_Extra/Groff/Man Page/Man Page.sublime-syntax
 index 57834af..6648664 100644
 --- syntaxes/02_Extra/Groff/Man Page/Man Page.sublime-syntax	
 +++ syntaxes/02_Extra/Groff/Man Page/Man Page.sublime-syntax	
@@ -4,9 +4,9 @@
 #   - man-pages(7)
 #   - groff(7)
 ---
 -name: Man Page (groff/troff)
 +name: Groff/troff
 scope: text.groff
 -file_extensions: [man, groff, troff, '1', '2', '3', '4', '5', '6', '7']
 +file_extensions: [groff, troff, '1', '2', '3', '4', '5', '6', '7', '8', '9']
 contexts:
   main:
@@ -1,5 +1,5 @@
 diff --git syntaxes/01_Packages/Markdown/Markdown.sublime-syntax syntaxes/01_Packages/Markdown/Markdown.sublime-syntax
-index 19dc685d..6afd87ae 100644
+index 19dc685d..44440c7f 100644
 --- syntaxes/01_Packages/Markdown/Markdown.sublime-syntax
 +++ syntaxes/01_Packages/Markdown/Markdown.sublime-syntax
@@ -24,7 +24,6 @@ variables:
@@ -166,3 +166,12 @@ index 19dc685d..6afd87ae 100644
     - match: ^\s*$\n?
       scope: invalid.illegal.non-terminated.bold-italic.markdown
       pop: true
@@ -1152,7 +1110,7 @@ contexts:
     - match: |-
          (?x)
           {{fenced_code_block_start}}
 -          ((?i:rust))
 +          ((?i:rust|rs))
           {{fenced_code_block_trailing_infostring_characters}}
       captures:
         0: meta.code-fence.definition.begin.rust.markdown-gfm
@@ -0,0 +1,13 @@
 diff --git syntaxes/02_Extra/MediaWiki/MediawikiNG.sublime-syntax syntaxes/02_Extra/MediaWiki/MediawikiNG.sublime-syntax
 index f542c9e..8eaf020 100644
 --- syntaxes/02_Extra/MediaWiki/MediawikiNG.sublime-syntax
 +++ syntaxes/02_Extra/MediaWiki/MediawikiNG.sublime-syntax
@@ -1,7 +1,7 @@
 %YAML 1.2
 ---
 # http://www.sublimetext.com/docs/3/syntax.html
 -name: Mediawiki NG
 +name: MediaWiki
 file_extensions: [mediawiki, wikipedia, wiki]
 scope: text.html.mediawiki
@@ -0,0 +1,36 @@
 diff --git themes/sublime-monokai-extended/Monokai\ Extended.tmTheme themes/sublime-monokai-extended/Monokai\ Extended.tmTheme
 index 9c2aa3e..180cbbf 100644
 --- themes/sublime-monokai-extended/Monokai Extended.tmTheme	
 +++ themes/sublime-monokai-extended/Monokai Extended.tmTheme	
@@ -810,11 +810,11 @@
       <key>name</key>
       <string>JSON String</string>
       <key>scope</key>
 -      <string>meta.structure.dictionary.json string.quoted.double.json</string>
 +      <string>meta.mapping.key.json string.quoted.double.json, punctuation.separator.sequence.csv</string>
       <key>settings</key>
       <dict>
         <key>foreground</key>
 -        <string>#cfcfc2</string>
 +        <string>#fd971f</string>
       </dict>
     </dict>
     <dict>
@@ -1027,7 +1027,7 @@
       <key>name</key>
       <string>Invalid</string>
       <key>scope</key>
 -      <string>invalid</string>
 +      <string>invalid, markup.error</string>
       <key>settings</key>
       <dict>
         <key>background</key>
@@ -1042,7 +1042,7 @@
       <key>name</key>
       <string>Invalid deprecated</string>
       <key>scope</key>
 -      <string>invalid.deprecated</string>
 +      <string>invalid.deprecated, markup.warning</string>
       <key>settings</key>
       <dict>
         <key>background</key>
@@ -0,0 +1,15 @@
 diff --git syntaxes/01_Packages/Python/Python.sublime-syntax syntaxes/01_Packages/Python/Python.sublime-syntax
 index 2acd86d8..86257f7b 100644
 --- syntaxes/01_Packages/Python/Python.sublime-syntax
 +++ syntaxes/01_Packages/Python/Python.sublime-syntax
@@ -988,10 +988,6 @@ contexts:
         - match: \}
           scope: punctuation.section.mapping-or-set.end.python
           set: after-expression
 -        - match: (?={{simple_expression}}:|\s*\*\*)
 -          set: inside-dictionary
 -        - match: (?={{simple_expression}}[,}]|\s*\*)
 -          set: inside-set
         - match: ','
           scope: punctuation.separator.set.python
           set: inside-set
@@ -1,8 +1,8 @@
 diff --git syntaxes/01_Packages/ShellScript/Bash.sublime-syntax syntaxes/01_Packages/ShellScript/Bash.sublime-syntax
-index e973e319..a703cef8 100644
+index e973e319..07c170a7 100644
 --- syntaxes/01_Packages/ShellScript/Bash.sublime-syntax
 +++ syntaxes/01_Packages/ShellScript/Bash.sublime-syntax
-@@ -30,8 +30,8 @@ file_extensions:
+@@ -30,12 +30,12 @@ file_extensions:
   - .zshenv
   - .zshrc
   - PKGBUILD  # https://jlk.fjfi.cvut.cz/arch/manpages/man/PKGBUILD.5
@@ -13,3 +13,8 @@ index e973e319..a703cef8 100644
 first_line_match: |
   (?x)
 -    ^\#! .* \b(bash|zsh|sh|tcsh|ash)\b
 +    ^\#! .* \b(bash|zsh|sh|tcsh|ash|dash)\b
   | ^\# \s* -\*- [^*]* mode: \s* shell-script [^*]* -\*-
 #-------------------------------------------------------------------------------
@@ -0,0 +1,13 @@
 diff --git syntaxes/02_Extra/TodoTxt/TodoTxt.sublime-syntax syntaxes/02_Extra/TodoTxt/TodoTxt.sublime-syntax
 index 6c75dbb..0115978 100644
 --- syntaxes/02_Extra/TodoTxt/TodoTxt.sublime-syntax
 +++ syntaxes/02_Extra/TodoTxt/TodoTxt.sublime-syntax
@@ -68,7 +68,7 @@ contexts:
     - match: (\s+[^\s:]+:[^\s:]+)+\s*$
       comment: Custom attributes
 -      scope: variable.annotation.todotxt.attribute
 +      scope: variable.other.todotxt.attribute
   comments:
     # Comments begin with a '//' and finish at the end of the line.
@@ -0,0 +1,20 @@
 diff --git themes/TwoDark/TwoDark.tmTheme themes/TwoDark/TwoDark.tmTheme
 index 87fd358..56376d3 100644
 --- themes/TwoDark/TwoDark.tmTheme
 +++ themes/TwoDark/TwoDark.tmTheme
@@ -533,7 +533,7 @@
 			<key>name</key>
 			<string>Json key</string>
 			<key>scope</key>
 -			<string>source.json                           meta.structure.dictionary.json                              string.quoted.double.json</string>
 +			<string>source.json                           meta.mapping.key.json                              string.quoted.double.json</string>
 			<key>settings</key>
 			<dict>
 				<key>foreground</key>
@@ -875,4 +875,4 @@
 	<key>comment</key>
 	<string>Work in progress</string>
 </dict>
 -</plist>
 \ No newline at end of file
 +</plist>
@@ -0,0 +1,12 @@
 diff --git syntaxes/01_Packages/XML/XML.sublime-syntax syntaxes/01_Packages/XML/XML.sublime-syntax
 index ad7d9c87..af4a00f0 100644
 --- syntaxes/01_Packages/XML/XML.sublime-syntax
 +++ syntaxes/01_Packages/XML/XML.sublime-syntax
@@ -12,6 +12,7 @@ file_extensions:
   - rss
   - opml
   - svg
 +  - xaml
 first_line_match: |-
     (?x:
       ^(?:
@@ -1,46 +1,78 @@
 %YAML 1.2
 ---
-# http://www.sublimetext.com/docs/3/syntax.html
+# See http://www.sublimetext.com/docs/3/syntax.html
-name: Advanced CSV
+name: Comma Separated Values
 file_extensions:
  - csv
  - tsv
-scope: text.advanced_csv
+scope: text.csv
 variables:
  field_separator: (?:[,;\t])
  record_separator: (?:$\n?)
 contexts:
  prototype:
    - match: (?={{record_separator}})
      pop: true
  fields:
    - match: ''
      push:
        - field_or_record_separator
        - field4
        - field_or_record_separator
        - field3
        - field_or_record_separator
        - field2
        - field_or_record_separator
        - field1
  main:
-    - match: (\")
+    - meta_include_prototype: false
-      captures:
+    - match: '^'
-        1: string.quoted.double.advanced_csv
+      set: fields
-      push:
+
-        - meta_scope: meta.quoted.advanced_csv
+  field_or_record_separator:
-        - match: (\")
+    - meta_include_prototype: false
-          captures:
+    - match: '{{record_separator}}'
-            1: string.quoted.double.advanced_csv
+      scope: punctuation.terminator.record.csv
-          pop: true
+      pop: true
-        - include: main
+    - match: '{{field_separator}}'
-    - match: '(\[([+-]?\d*)(\:)?([+-]?\d*)(\,)?([+-]?\d*)(\:)?([+-]?\d*)\])?\s*([<>v^])?\s*(=)'
+      scope: punctuation.separator.sequence.csv
-      captures:
+      pop: true
-        1: keyword.operator.advanced_csv
+
-        2: constant.numeric.formula.advanced_csv
+  field_contents:
-        4: constant.numeric.formula.advanced_csv
+    - match: '"'
-        6: constant.numeric.formula.advanced_csv
+      scope: punctuation.definition.string.begin.csv
-        8: constant.numeric.formula.advanced_csv
+      push: double_quoted_string
-        9: keyword.operator.advanced_csv
+
-        10: keyword.operator.advanced_csv
+    - match: (?={{field_separator}}|{{record_separator}})
-      push:
+      pop: true
-        - meta_scope: meta.range.advanced_csv
+
-        - match: (?=(\")|$)
+  double_quoted_string:
-          pop: true
+    - meta_include_prototype: false
-        - include: scope:source.python
+    - meta_scope: string.quoted.double.csv
-    - match: '(?<=^|,|\s|\")([0-9.eE+-]+)(?=$|,|\s|\")'
+    - match: '""'
-      scope: meta.number.advanced_csv
+      scope: constant.character.escape.csv
-      captures:
+    - match: '"'
-        1: constant.numeric.advanced_csv
+      scope: punctuation.definition.string.end.csv
-    - match: '(?<=^|,|\s|\")([^, \t\"]+)(?=$|,|\s|\")'
+      pop: true
-      scope: meta.nonnumber.advanced_csv
+
-      captures:
+  field1:
-        1: storage.type.advanced_csv
+    - match: ''
-    - match: (\,)
+      set:
-      scope: meta.delimiter.advanced_csv
+        - meta_content_scope: meta.field-1.csv support.type
-      captures:
+        - include: field_contents
-        1: keyword.operator.advanced_csv
+  field2:
    - match: ''
      set:
        - meta_content_scope: meta.field-2.csv support.function
        - include: field_contents
  field3:
    - match: ''
      set:
        - meta_content_scope: meta.field-3.csv constant.numeric
        - include: field_contents
  field4:
    - match: ''
      set:
        - meta_content_scope: meta.field-4.csv keyword.operator
        - include: field_contents
@@ -1,6 +1,6 @@
 %YAML 1.2
 ---
-# http://www.sublimetext.com/docs/3/syntax.html
+# http://www.sublimetext.com/docs/syntax.html
 name: Dart
 file_extensions:
  - dart
@@ -9,7 +9,7 @@ contexts:
  main:
    - match: ^(#!.*)$
      scope: meta.preprocessor.script.dart
-    - match: ^\s*\b(library|import|export|part of|part)\b
+    - match: ^\w*\b(library|import|part of|part|export)\b
      captures:
        0: keyword.other.import.dart
      push:
@@ -19,242 +19,114 @@ contexts:
            0: punctuation.terminator.dart
          pop: true
        - include: strings
-        - match: \b(as|show|hide|deferred)\b
+        - include: comments
        - match: \b(as|show|hide)\b
          scope: keyword.other.import.dart
    - include: comments
-    - include: constants-and-special-vars
+    - include: punctuation
    - include: annotations
    - include: decl-typedef
    - include: decl-class
    - include: decl-enum
    - include: decl-function
    - include: keywords
    - include: constants-and-special-vars
    - include: strings
  annotations:
-    - match: '^(?:\s*)((@)([a-zA-Z0-9_]+))'
+    - match: '@[a-zA-Z]+'
-      captures:
+      scope: storage.type.annotation.dart
        1: annotation.dart
        2: entity.name.function.annotation.dart
        3: support.type.dart
  comments:
    - match: /\*\*/
      scope: comment.block.empty.dart
      captures:
        0: punctuation.definition.comment.dart
    - include: comments-doc-oldschool
    - include: comments-doc
    - include: comments-inline
-  comments-inline:
+  comments-block:
    - match: /\*
      push:
        - meta_scope: comment.block.dart
        - match: \*/
          pop: true
-        - include: scope:text.dart-doccomments
+        - include: comments-block
-    - match: (///)
+  comments-doc:
-      captures:
+    - match: ///
        1: marker.dart
      push:
-        - meta_scope: comment.line.triple-slash.dart
+        - meta_scope: comment.block.documentation.dart
-        - match: $
+        - match: .*
          pop: true
-        - include: scope:text.dart-doccomments
+        - include: dartdoc
-    - match: (//)
+  comments-doc-oldschool:
-      captures:
+    - match: /\*\*
        1: marker.dart
      push:
-        - meta_scope: comment.line.double-slash.dart
+        - meta_scope: comment.block.documentation.dart
-        - match: $
+        - match: \*/
          pop: true
-        - include: scope:text.dart-doccomments
+        - include: comments-doc-oldschool
        - include: comments-block
        - include: dartdoc
  comments-inline:
    - include: comments-block
    - match: ((//).*)$
      captures:
        1: comment.line.double-slash.dart
  constants-and-special-vars:
-    - match: \b(true|false|null)\b
+    - match: (?<!\$)\b(true|false|null)\b(?!\$)
      scope: constant.language.dart
-    - match: \b(this|super)\b
+    - match: (?<!\$)\b(this|super)\b(?!\$)
      scope: variable.language.dart
-    - match: '\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)\b'
+    - match: '(?<!\$)\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)\b(?!\$)'
      scope: constant.numeric.dart
-  decl-class:
+    - match: '(?<![a-zA-Z0-9_$])([_$]*[A-Z][a-zA-Z0-9_$]*|bool\b|num\b|int\b|double\b|dynamic\b)'
-    - match: \bclass\b
+      scope: support.class.dart
    - match: '([_$]*[a-z][a-zA-Z0-9_$]*)(<|\(|\s+=>)'
      captures:
-        0: keyword.control.new.dart
+        1: entity.name.function.dart
  dartdoc:
    - match: '(\[.*?\])'
      captures:
        0: variable.name.source.dart
    - match: '^ {4,}(?![ \*]).*'
      captures:
        0: variable.name.source.dart
    - match: '```.*?$'
      push:
-        - meta_scope: meta.declaration.class.dart
+        - meta_content_scope: variable.other.source.dart
-        - match: "(?={)"
+        - match: '```'
          pop: true
-        - include: keywords
+    - match: (`.*?`)
        - match: "[A-Za-z_][A-Za-z0-9_]*"
          scope: class.name.dart
  decl-enum:
    - match: \benum\b
      captures:
-        0: keyword.declaration.dart
+        0: variable.other.source.dart
-      push:
+    - match: (`.*?`)
        - meta_scope: meta.declaration.enum.dart
        - match: "(?={)"
          pop: true
        - include: keywords
        - match: "[A-Za-z_][A-Za-z0-9_]*"
          scope: enum.name.dart
  decl-function:
    - match: ^\s*(?:\b(void|bool|num|int|double|dynamic|var|String|List|Map)\b)\s+(get)\s+(\w+)\s+(?==>)
      comment: A getter with a primitive return type.
      scope: meta.declaration.function.dart
      captures:
-        1: storage.type.primitive.dart
+        0: variable.other.source.dart
-        2: keyword.declaration.dart
+    - match: (\* ((    ).*))$
        3: function.name.dart
    - match: ^\s*(?:\b(\w+)\b\s+)?(get)\s+(\w+)\s+(?==>)
      comment: A getter with a user-defined return type or no return type.
      scope: meta.declaration.function.dart
      captures:
-        1: type.user-defined.dart
+        2: variable.other.source.dart
-        2: keyword.declaration.dart
+    - match: (\*    .*)$
        3: function.name.dart
    - match: ^\s*(set)\s+(\w+)(?=\()
      comment: A setter.
      captures:
        1: keyword.declaration.dart
        2: function.name.dart
      push:
        - meta_scope: meta.declaration.function.dart
        - match: \)
          pop: true
        - include: comments-inline
        - include: decl-function-parameter
        - include: strings
        - include: keywords
    - match: ^\s*(?:\b(void|bool|num|int|double|dynamic|var|String|List|Map)\b)\s+(\w+)(?=\()
      comment: A function with a primitive return type.
      captures:
        1: storage.type.primitive.dart
        2: function.name.dart
      push:
        - meta_scope: meta.declaration.function.dart
        - match: \)
          pop: true
        - include: comments-inline
        - include: decl-function-parameter
        - include: strings
        - include: keywords
    - match: ^\s*(?:\b(return)\b)\s+(\w+)(?=\()
      comment: A function invocation after 'return'
      captures:
        1: keyword.control.dart
        2: function.name.dart
      push:
        - meta_scope: meta.invocation.function.dart
        - match: \)
          pop: true
        - include: comments-inline
        - include: decl-function-parameter
        - include: strings
        - include: keywords
    - match: ^\s*\b(new)\b\s+(\w+)(?=\()
      comment: A class instantiation after 'new'
      captures:
        1: keyword.declaration.dart
        2: function.name.dart
      push:
        - meta_scope: meta.invocation.function.dart
        - match: \)
          pop: true
        - include: comments-inline
        - include: decl-function-parameter
        - include: strings
        - include: keywords
  decl-function-parameter:
    - include: constants-and-special-vars
    - match: (?:\b(void|bool|num|int|double|dynamic|var|String|List|Map)\b)\s+(\w+)(?=\()
      comment: A function with a primitive return type.
      captures:
        1: storage.type.primitive.dart
        2: function.name.dart
      push:
        - meta_scope: meta.parameter.function.dart
        - match: \)
          pop: true
        - include: decl-function-parameter
        - include: strings
        - include: keywords
    - match: \b(new)\b\s+(\w+)(?=\()
      comment: A class instantiation after 'new'
      captures:
        1: keyword.declaration.dart
        2: function.name.dart
      push:
        - meta_scope: meta.invocation.function.dart
        - match: \)
          pop: true
        - include: decl-function-parameter
        - include: strings
        - include: keywords
    - match: (?:\b(\w+)\b)\s+(\w+)(?=\()
      comment: A function with a user-defined return type.
      captures:
        1: type.user-defined.dart
        2: function.name.dart
      push:
        - meta_scope: meta.parameter.function.dart
        - match: \)
          pop: true
        - include: decl-function-parameter
        - include: strings
        - include: keywords
    - match: (\w+)(?=\()
      comment: A function with no return type.
      captures:
        1: function.name.dart
      push:
        - meta_scope: meta.parameter.function.dart
        - match: \)
          pop: true
        - include: decl-function-parameter
        - include: strings
        - include: keywords
  decl-typedef:
    - match: typedef
      captures:
        0: keyword.control.new.dart
      push:
        - meta_scope: meta.declaration.typedef.dart
        - match: ;
          captures:
            0: punctuation.terminator.dart
          pop: true
        - match: '(?:\b(void|bool|num|int|double|dynamic|var|String|List|Map)\b|([a-zA-Z_][a-zA-Z0-9_]*))\s+([a-zA-Z_][a-zA-Z0-9_]+)'
          captures:
            1: storage.type.primitive.dart
            2: typedef.return.dart
            3: typedef.name.dart
        - match: \(
          push:
            - meta_scope: typedef.params.dart
            - match: \)
              pop: true
            - include: keywords
  keywords:
-    - match: \bassert\b
+    - match: (?<!\$)\bas\b(?!\$)
      scope: keyword.control.assert.dart
    - match: \bas\b
      scope: keyword.cast.dart
-    - match: \b(try|catch|finally|throw|on|rethrow)\b
+    - match: (?<!\$)\b(try|on|catch|finally|throw|rethrow)\b(?!\$)
      scope: keyword.control.catch-exception.dart
-    - match: \s+\?\s+|\s+:\s+
+    - match: (?<!\$)\b(break|case|continue|default|do|else|for|if|in|return|switch|while)\b(?!\$)
      scope: keyword.control.ternary.dart
    - match: \b(break|case|continue|default|do|else|for|if|in|return|switch|while)\b
      scope: keyword.control.dart
-    - match: \b(async\*|async|await\*|await|yield)\b
+    - match: (?<!\$)\b(sync(\*)?|async(\*)?|await|yield(\*)?)\b(?!\$)
-      scope: keyword.control.async.dart
+      scope: keyword.control.dart
-    - match: \b(new)\b
+    - match: (?<!\$)\bassert\b(?!\$)
      scope: keyword.control.dart
    - match: (?<!\$)\b(new)\b(?!\$)
      scope: keyword.control.new.dart
-    - match: \b(abstract|extends|external|factory|implements|with|interface|get|native|operator|set|typedef)\b
+    - match: (?<!\$)\b(abstract|class|enum|extends|external|factory|implements|get|mixin|native|operator|set|typedef|with|covariant)\b(?!\$)
      scope: keyword.declaration.dart
-    - match: \b(is\!?)\b
+    - match: (?<!\$)\b(is\!?)\b(?!\$)
      scope: keyword.operator.dart
    - match: '\?|:'
      scope: keyword.operator.ternary.dart
    - match: (<<|>>>?|~|\^|\||&)
      scope: keyword.operator.bitwise.dart
    - match: ((&|\^|\||<<|>>>?)=)
      scope: keyword.operator.assignment.bitwise.dart
-    - match: (===?|!==?|<=?|>=?)
+    - match: (=>)
      scope: keyword.operator.closure.dart
    - match: (==|!=|<=?|>=?)
      scope: keyword.operator.comparison.dart
    - match: '(([+*/%-]|\~)=)'
      scope: keyword.operator.assignment.arithmetic.dart
@@ -266,56 +138,22 @@ contexts:
      scope: keyword.operator.arithmetic.dart
    - match: (!|&&|\|\|)
      scope: keyword.operator.logical.dart
    - match: (?<!\$)\b(static|final|const)\b(?!\$)
      scope: storage.modifier.dart
    - match: (?<!\$)\b(?:void|var)\b(?!\$)
      scope: storage.type.primitive.dart
  punctuation:
    - match: ','
      scope: punctuation.comma.dart
    - match: ;
      scope: punctuation.terminator.dart
    - match: \b(static|final|const)\b
      scope: storage.modifier.dart
    - match: \b(?:void|bool|num|int|double|dynamic|var|String|List|Map)\b
      scope: storage.type.primitive.dart
  regexp:
    - match: '\\[^''"]'
      scope: constant.character.escaped.regex.dart
    - match: \(
      push:
        - meta_content_scope: meta.capture.regex.dart
        - match: \)
          pop: true
        - match: \?(:|=|!)
          scope: ignore.capture.regex.dart
    - match: \*|\+|\?|\.|\|
      scope: keyword.other.regex.dart
    - match: \^|\$
      scope: keyword.other.regex.dart
    - match: \.
-      scope: constant.other.regex.dart
+      scope: punctuation.dot.dart
    - match: '\[(\^)?'
      captures:
        1: keyword.other.negation.regex.dart
      push:
        - meta_scope: constant.character.range.regex.dart
        - match: '\]'
          pop: true
        - match: '\\[^"'']'
          scope: constant.character.escaped.regex.dart
    - match: '\{(?:\d+)?,(?:\d+)?\}'
      scope: keyword.other.regex.dart
  string-interp:
-    - match: '(\$)(\{)'
+    - match: '\$((\w+)|\{([^{}]+)\})'
      captures:
        1: keyword.other.dart
        2: keyword.other.dart
      push:
        - meta_scope: interpolation.dart
        - meta_content_scope: source.dart
        - match: '(\})'
          captures:
            1: keyword.other.dart
          pop: true
        - include: main
    - match: (\$)(\w+)
      captures:
        1: keyword.other.dart
        2: variable.parameter.dart
        3: variable.parameter.dart
    - match: \\.
      scope: constant.character.escape.dart
  strings:
@@ -328,7 +166,7 @@ contexts:
    - match: (?<!r)'''
      push:
        - meta_scope: string.interpolated.triple.single.dart
-        - match: "'''(?!')"
+        - match: '''''''(?!'')'
          pop: true
        - include: string-interp
    - match: r"""
@@ -339,9 +177,9 @@ contexts:
    - match: r'''
      push:
        - meta_scope: string.quoted.triple.single.dart
-        - match: "'''(?!')"
+        - match: '''''''(?!'')'
          pop: true
-    - match: (?<!\\|r)"
+    - match: (?<!\|r)"
      push:
        - meta_scope: string.interpolated.double.dart
        - match: '"'
@@ -354,16 +192,20 @@ contexts:
        - meta_scope: string.quoted.double.dart
        - match: '"'
          pop: true
-        - include: regexp
+        - match: \n
          scope: invalid.string.newline
    - match: (?<!\|r)'
      push:
        - meta_scope: string.interpolated.single.dart
        - match: "'"
          pop: true
        - match: \n
          scope: invalid.string.newline
        - include: string-interp
    - match: r'
      push:
        - meta_scope: string.quoted.single.dart
        - match: "'"
          pop: true
-        - include: regexp
+        - match: \n
          scope: invalid.string.newline
@@ -4,11 +4,11 @@
 name: DotENV
 file_extensions:
  - .env
  - .envrc
  - .env.dist
  - .env.local
  - .env.sample
  - .env.example
  - .env.template
  - .env.test
  - .env.test.local
  - .env.testing
@@ -19,8 +19,15 @@ file_extensions:
  - .env.production
  - .env.production.local
  - .env.dusk.local
  - .flaskenv
  - .env.staging
  - .env.default
  - .env.defaults
  - .envrc
  - .flaskenv
  - env
  - env.example
  - env.sample
  - env.template
 scope: source.env
 contexts:
  main:
@@ -5,6 +5,7 @@ name: fstab
 file_extensions:
  - fstab
  - crypttab
  - mtab
 scope: source.fstab
 contexts:
@@ -94,7 +95,7 @@ contexts:
  fstab_dump:
    - include: comment
-    - match: '\s*[01]\s*'
+    - match: '\s*[012]\s*'
      comment: dump field
      scope: constant.numeric
      set: fstab_pass
@@ -106,7 +107,7 @@ contexts:
  fstab_pass:
    - include: comment
-    - match: '\s*[01]\s*'
+    - match: '\s*[012]\s*'
      comment: pass field
      scope: constant.numeric
      set: expected_eol
@@ -5,8 +5,8 @@ name: INI
 file_extensions:
  - ini
  - INI
-  - inf
+  - "inf"
-  - INF
+  - "INF"
  - reg
  - REG
  - lng
@@ -16,6 +16,9 @@ file_extensions:
  - url
  - URL
  - .editorconfig
  - .coveragerc
  - .pylintrc
  - .gitlint
  - .hgrc
  - hgrc
 scope: source.ini
@@ -0,0 +1,125 @@
 %YAML 1.2
 ---
 # http://www.sublimetext.com/docs/3/syntax.html
 name: Lean
 file_extensions:
  - lean
 scope: source.lean
 contexts:
  main:
    - include: comments
    - match: '\b(?<!\.)(inductive|coinductive|structure|theorem|axiom|axioms|abbreviation|lemma|definition|def|instance|class|constant)\b\s+(\{[^}]*\})?'
      captures:
        1: keyword.other.definitioncommand.lean
      push:
        - meta_scope: meta.definitioncommand.lean
        - match: '(?=\bwith\b|\bextends\b|[:\|\(\[\{⦃<>])'
          pop: true
        - include: comments
        - include: definitionName
        - match: ","
    - match: \b(Prop|Type|Sort)\b
      scope: storage.type.lean
    - match: '\battribute\b\s*\[[^\]]*\]'
      scope: storage.modifier.lean
    - match: '@\[[^\]]*\]'
      scope: storage.modifier.lean
    - match: \b(?<!\.)(private|meta|mutual|protected|noncomputable)\b
      scope: keyword.control.definition.modifier.lean
    - match: \b(sorry)\b
      scope: invalid.illegal.lean
    - match: '#print\s+(def|definition|inductive|instance|structure|axiom|axioms|class)\b'
      scope: keyword.other.command.lean
    - match: '#(print|eval|reduce|check|help|exit|find|where)\b'
      scope: keyword.other.command.lean
    - match: \b(?<!\.)(import|export|prelude|theory|definition|def|abbreviation|instance|renaming|hiding|exposing|parameter|parameters|begin|constant|constants|lemma|variable|variables|theorem|example|open|axiom|inductive|coinductive|with|structure|universe|universes|alias|precedence|reserve|postfix|prefix|infix|infixl|infixr|notation|end|using|namespace|section|local|set_option|extends|include|omit|class|classes|instances|raw|run_cmd|restate_axiom)(?!\.)\b
      scope: keyword.other.lean
    - match: \b(?<!\.)(calc|have|this|match|do|suffices|show|by|in|at|let|forall|fun|exists|assume|from|obtain|haveI|λ)(?!\.)\b
      scope: keyword.other.lean
    - match: «
      push:
        - meta_content_scope: entity.name.lean
        - match: »
          pop: true
    - match: \b(?<!\.)(if|then|else)\b
      scope: keyword.control.lean
    - match: '"'
      captures:
        0: punctuation.definition.string.begin.lean
      push:
        - meta_scope: string.quoted.double.lean
        - match: '"'
          captures:
            0: punctuation.definition.string.end.lean
          pop: true
        - match: '\\[\\"nt'']'
          scope: constant.character.escape.lean
        - match: '\\x[0-9A-Fa-f][0-9A-Fa-f]'
          scope: constant.character.escape.lean
        - match: '\\u[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]'
          scope: constant.character.escape.lean
    - match: '''[^\\'']'''
      scope: string.quoted.single.lean
    - match: '''(\\(x..|u....|.))'''
      scope: string.quoted.single.lean
      captures:
        1: constant.character.escape.lean
    - match: '`+[^\[(]\S+'
      scope: entity.name.lean
    - match: '\b([0-9]+|0([xX][0-9a-fA-F]+))\b'
      scope: constant.numeric.lean
  blockComment:
    - match: /-
      push:
        - meta_scope: comment.block.lean
        - match: "-/"
          pop: true
        - include: scope:source.lean.markdown
        - include: blockComment
  comments:
    - include: dashComment
    - include: docComment
    - include: stringBlock
    - include: modDocComment
    - include: blockComment
  dashComment:
    - match: (--)
      captures:
        0: punctuation.definition.comment.lean
      push:
        - meta_scope: comment.line.double-dash.lean
        - match: $
          pop: true
        - include: scope:source.lean.markdown
  definitionName:
    - match: '\b[^:«»\(\)\{\}[:space:]=→λ∀?][^:«»\(\)\{\}[:space:]]*'
      scope: entity.name.function.lean
    - match: «
      push:
        - meta_content_scope: entity.name.function.lean
        - match: »
          pop: true
  docComment:
    - match: /--
      push:
        - meta_scope: comment.block.documentation.lean
        - match: "-/"
          pop: true
        - include: scope:source.lean.markdown
        - include: blockComment
  modDocComment:
    - match: /-!
      push:
        - meta_scope: comment.block.documentation.lean
        - match: "-/"
          pop: true
        - include: scope:source.lean.markdown
        - include: blockComment
  stringBlock:
    - match: /-"
      push:
        - meta_scope: comment.block.string.lean
        - match: '"-/'
          pop: true
        - include: scope:source.lean.markdown
        - include: blockComment
@@ -0,0 +1,400 @@
 %YAML 1.2
 ---
 # http://www.sublimetext.com/docs/3/syntax.html
 name: LiveScript
 comment: "LiveScript Syntax: version 1"
 file_extensions:
  - ls
  - Slakefile
  - ls.erb
 first_line_match: ^#!.*\bls
 scope: source.livescript
 contexts:
  main:
    - match: |-
        (?x)
          !?[~-]{1,2}>\*?
          |<[~-]{1,2}!?
          |\(\s* (?=    instanceof[\s)]|and[\s)]|or[\s)]|is[\s)]|isnt[\s)]|in[\s)]|import[\s)]|import\ all[\s)]     |\.|[-+/*%^&<>=|][\b\s)\w$]|\*\*|\%\%)
          |      (?<=[\s(]instanceof|[\s(]and|[\s(]or|[\s(]is|[\s(]isnt|[\s(]in|[\s(]import|[\s(]import\ all|[\s(]do|\.|\*\*|\%\%|[\b\s(\w$][-+/*%^&<>=|]) \s*\)
      scope: storage.type.function.livescript
    - match: \/\*
      captures:
        0: punctuation.definition.comment.livescript
      push:
        - meta_scope: comment.block.livescript
        - match: \*\/
          captures:
            0: punctuation.definition.comment.livescript
          pop: true
        - match: '@\w*'
          scope: storage.type.annotation.livescriptscript
    - match: '(#)(?!\{).*$\n?'
      scope: comment.line.number-sign.livescript
      captures:
        1: punctuation.definition.comment.livescript
    - match: '((?:!|~|!~|~!)?function\*?)\s+([$\w\-]*[$\w]+)'
      captures:
        1: storage.type.function.livescript
        2: entity.name.function.livescript
    - match: (new)\s+(\w+(?:\.\w*)*)
      captures:
        1: keyword.operator.new.livescript
        2: entity.name.type.instance.livescript
    - match: \b(package|private|protected|public|interface|enum|static)(?!-)\b
      scope: keyword.illegal.livescript
    - match: "'''"
      captures:
        0: punctuation.definition.string.begin.livescript
      push:
        - meta_scope: string.quoted.heredoc.livescript
        - match: "'''"
          captures:
            0: punctuation.definition.string.end.livescript
          pop: true
    - match: '"""'
      captures:
        0: punctuation.definition.string.begin.livescript
      push:
        - meta_scope: string.quoted.double.heredoc.livescript
        - match: '"""'
          captures:
            0: punctuation.definition.string.end.livescript
          pop: true
        - match: \\.
          scope: constant.character.escape.livescript
        - include: interpolated_livescript
    - match: "``"
      captures:
        0: punctuation.definition.string.begin.livescript
      push:
        - meta_scope: string.quoted.script.livescript
        - match: "``"
          captures:
            0: punctuation.definition.string.end.livescript
          pop: true
        - match: '\\(x[0-9A-Fa-f]{2}|[0-2][0-7]{0,2}|3[0-6][0-7]|37[0-7]?|[4-7][0-7]?|.)'
          scope: constant.character.escape.livescript
    - match: '<\['
      push:
        - meta_scope: string.array-literal.livescript
        - match: '\]>'
          pop: true
    - match: '/{2}(?![\s=/*+{}?]).*?[^\\]/[igmy]{0,4}(?![a-zA-Z0-9])/{2}'
      scope: string.regexp.livescript
    - match: '/{2}\n'
      push:
        - meta_scope: string.regexp.livescript
        - match: "/{2}[imgy]{0,4}"
          pop: true
        - include: embedded_spaced_comment
        - include: interpolated_livescript
    - match: "/{2}"
      push:
        - meta_scope: string.regexp.livescript
        - match: "/{2}[imgy]{0,4}"
          pop: true
        - match: '\\(x[0-9A-Fa-f]{2}|[0-2][0-7]{0,2}|3[0-6][0-7]|37[0-7]?|[4-7][0-7]?|.)'
          scope: constant.character.escape.livescript
        - include: interpolated_livescript
    - match: '/(?![\s=/*+{}?]).*?[^\\]/[igmy]{0,4}(?![a-zA-Z0-9])'
      scope: string.regexp.livescript
    - match: |-
        (?x)
          \b(?<![\.\$\-@])(
            instanceof|new|delete|typeof|and|or|is|isnt|not
          )(?!\-|\s*:)\b
      scope: keyword.operator.livescript
    - match: <\||\|>
      scope: keyword.operator.livescript
    - match: "=>"
      scope: keyword.control.livescript
    - match: |-
        (?x)
          \b(?<![\.\$\-@])(?:
          return|break|continue|throw
          |try|if|while|for|for\s+own|switch|unless|until
          |catch|finally|else|nobreak|case|default|fallthrough|when|otherwise|then
          |yield
          )(?!\-|\s*:)\b
      scope: keyword.control.livescript
    - match: |-
        (?x)
          and=|or=|%|&|\^|\*|\/|(?<![a-zA-Z$_])(\-)?\-(?!\-?>)|\+\+|\+|
          ~(?!~?>)|==|=|!=|<=|>=|<<=|>>=|
          >>>=|<>|<(?!\[)|(?<!\])>|(?<!\w)!(?!([~\-]+)?>)|&&|\.\.(\.)?|\s\.\s|\?|\|\||\:|\*=|(?<!\()/=|%=|\+=|\-=|\.=|&=
          |\^=
      scope: keyword.operator.livescript
    - match: |-
        (?x)
          \b(?<![\.\$\-@])(?:
          function
          )(?!\-|\s*:)\b
      scope: storage.type.function.livescript
    - match: |-
        (?x)
          \b(?<![\.\$\-@])(?:
          this|throw|then|try|typeof!?|til|to
          |continue|const|case|catch|class
          |in|instanceof|import|import\s+all|implements|if|is
          |default|delete|debugger|do
          |for|for\s+own|finally|function|from|fallthrough
          |super|switch
          |else|nobreak|extends|export|eval
          |and|arguments
          |new|not
          |unless|until
          |while|with|when
          |of|or|otherwise
          |let|var|loop
          |match
          |by|yield
          )(?!\-|\s*:)\b
      scope: keyword.other.livescript
    - match: '([a-zA-Z\$_](?:[\w$.-])*)\s*(?!\::)((:)|(=(?!>)))\s*(?!(\s*!?\s*\(.*\))?\s*(!?[~-]{1,2}>\*?))'
      captures:
        1: variable.assignment.livescript
        3: punctuation.separator.key-value, keyword.operator.livescript
        4: keyword.operator.livescript
    - match: '(?<=\s|^)([\[\{])(?=.*?[\]\}]\s+[:=])'
      captures:
        0: keyword.operator.livescript
      push:
        - meta_scope: meta.variable.assignment.destructured.livescript
        - match: '([\]\}]\s*[:=])'
          captures:
            0: keyword.operator.livescript
          pop: true
        - include: variable_name
        - include: instance_variable
        - include: single_quoted_string
        - include: double_quoted_string
        - include: numeric
    - match: |-
        (?x)
          (\s*)
          (?=[a-zA-Z\$_])
          ([a-zA-Z\$_]([\w$.:-])*)\s*
          (?=[:=](\s*!?\s*\(.*\))?\s*(!?[~-]{1,2}>\*?))
      scope: meta.function.livescript
      captures:
        2: entity.name.function.livescript
        3: entity.name.function.livescript
        4: variable.parameter.function.livescript
        5: storage.type.function.livescript
    - match: \b(?<!\.)(true|on|yes)(?!\s*:)\b
      scope: constant.language.boolean.true.livescript
    - match: \b(?<!\.)(false|off|no)(?!\s*:)\b
      scope: constant.language.boolean.false.livescript
    - match: \b(?<!\.)(null|void)(?!\s*:)\b
      scope: constant.language.null.livescript
    - match: \b(?<!\.)(super|this|extends)(?!\s*:)\b
      scope: variable.language.livescript
    - match: '(class\b)\s+(@?[a-zA-Z$_][\w$.-]*)?(?:\s+(extends)\s+(@?[a-zA-Z$_][\w$.-]*))?'
      scope: meta.class.livescript
      captures:
        1: storage.type.class.livescript
        2: entity.name.type.class.livescript
        3: keyword.control.inheritance.livescript
        4: entity.other.inherited-class.livescript
    - match: \b(debugger|\\)\b
      scope: keyword.other.livescript
    - match: |-
        (?x)\b(
          Array|ArrayBuffer|Blob|Boolean|Date|document|event|Function|
          Int(8|16|32|64)Array|Math|Map|Number|
          Object|Proxy|RegExp|Set|String|WeakMap|
          window|Uint(8|16|32|64)Array|XMLHttpRequest
        )\b
      scope: support.class.livescript
    - match: \b(console)\b
      scope: entity.name.type.object.livescript
    - match: \b(Infinity|NaN|undefined)\b
      scope: constant.language.livescript
    - match: \;
      scope: punctuation.terminator.statement.livescript
    - match: ',[ |\t]*'
      scope: meta.delimiter.object.comma.livescript
    - match: \.
      scope: meta.delimiter.method.period.livescript
    - match: '\{|\}'
      scope: meta.brace.curly.livescript
    - match: \(|\)
      scope: meta.brace.round.livescript
    - match: '\[|\]\s*'
      scope: meta.brace.square.livescript
    - include: instance_variable
    - include: backslash_string
    - include: single_quoted_string
    - include: double_quoted_string
    - include: numeric
    - match: '()(@|@@|[$\w\-]*[$\w]+)\s*(`)'
      captures:
        1: keyword.operator.livescript
        2: meta.function-call.livescript
        3: keyword.operator.livescript
    - match: "`"
      scope: keyword.operator.livescript
    - match: '()(@|@@|[$\w\-]*[$\w]+)(?:(\??\!)|[(])'
      captures:
        1: keyword.operator.livescript
        2: meta.function-call.livescript
        3: keyword.operator.livescript
    - match: '(@|@@|[$\w\-]*[$\w]+)(\?)? (?!\s*(((by|of|and|or|with|when|unless|if|is|isnt|else|nobreak|for|from|not in|in|catch|til|to|then|import|extends|implements|instanceof)\b)|[=:.*\/+\-%\^<>][ =)]|[`}%*)]|/(?!.*?/)|&&|[.][^.]|=>|\/ +|\||\|\||\-\-|\+\+|\|>|<|\||$|\n|\#|/\*))'
      captures:
        1: meta.function-call.livescript
        2: keyword.operator.livescript
    - match: \| _
      scope: keyword.control.livescript
    - match: '\|(?![.])'
      scope: keyword.control.livescript
    - match: \|
      scope: keyword.operator.livescript
    - match: ((?<=console\.)(debug|warn|info|log|error|time(End|-end)|assert))\b
      scope: support.function.console.livescript
    - match: |-
        (?x)\b(
          decodeURI(Component)?|encodeURI(Component)?|eval|parse(Float|Int)|require
        )\b
      scope: support.function.livescript
    - match: |-
        (?x)(?<![.-])\b(
          map|filter|reject|partition|find|each|head|tail|last|initial|empty|
          values|keys|length|cons|append|join|reverse|fold(l|r)?1?|unfoldr|
          and(List|-list)|or(List|-list)|any|all|unique|sum|product|mean|compact|
          concat(Map|-map)?|maximum|minimum|scan(l|r)?1?|replicate|slice|apply|
          split(At|-at)?|take(While|-while)?|drop(While|-while)?|span|first|
          break(It|-it)|list(ToObj|-to-obj)|obj(ToFunc|-to-func)|
          pairs(ToObj|-to-obj)|obj(ToPairs|-to-pairs|ToLists|-to-lists)|
          zip(All|-all)?(With|-with)?|compose|curry|partial|flip|fix|
          sort(With|-with|By|-by)?|group(By|-by)|break(List|-list|Str|-str)|
          difference|intersection|union|average|flatten|chars|unchars|repeat|
          lines|unlines|words|unwords|max|min|negate|abs|signum|quot|rem|div|mod|
          recip|pi|tau|exp|sqrt|ln|pow|sin|cos|tan|asin|acos|atan|atan2|truncate|
          round|ceiling|floor|is(It|-it)NaN|even|odd|gcd|lcm|disabled__id
        )\b(?![.-])
      comment: |
        Generated by DOM query from http://gkz.github.com/prelude-ls/:
                    [].slice
                    .call(document.querySelectorAll(".nav-pills li a"))
                    .map(function(_) {return _.innerText})
                    .filter(function(_) {return _.trim() !== '})
                    .slice(2)
                    .join("|")
      scope: support.function.prelude.livescript
    - match: '(?x)(?<![.-])\b(that|it|e|_)\b'
      scope: support.function.semireserved.livescript
    - match: |-
        (?x)((?<=(\.|\]|\)))(
          apply|call|concat|every|filter|for(Each|-each)|
          from|has(Own|-own)(Property|-property)|index(Of|-of)|
          is(Prototype|-prototype)(Of|-of)|join|last(Index|-index)(Of|-of)|
          map|of|pop|property(Is|-is)(Enumerable|-enumerable)|push|
          reduce(Right|-right)?|reverse|shift|slice|some|sort|
          splice|to(Locale|-locale)?(String|-string)|unshift|valueOf
        ))\b(?!-)
      scope: support.function.method.array.livescript
    - match: |-
        (?x)((?<=Array\.)(
          isArray
        ))\b
      scope: support.function.static.array.livescript
    - match: |-
        (?x)((?<=Object\.)(
          create|define(Propert|-propert)(ies|y)|freeze|
          get(Own|-own)(Property|-property)(Descriptors?|Names)|
          get(Property|-property)(Descriptor|Names)|getPrototypeOf|
          is((Extensible|-extensible)|(Frozen|-frozen)|(Sealed|-sealed))?|
          keys|prevent(Extensions|-extensions)|seal
        ))\b
      scope: support.function.static.object.livescript
    - match: |-
        (?x)((?<=Math\.)(
          abs|acos|acosh|asin|asinh|atan|atan2|atanh|ceil|cos|cosh|exp|expm1|floor|
          hypot|log|log10|log1p|log2|max|min|pow|random|round|sign|sin|sinh|sqrt|
          tan|tanh|trunc
        ))\b
      scope: support.function.static.math.livescript
    - match: |-
        (?x)((?<=Number\.)(
          is(Finite|Integer|NaN)|to(Integer|-integer)
        ))\b
      scope: support.function.static.number.livescript
    - match: '[\$\w][\w-]*'
      scope: variable.other.livescript
  backslash_string:
    - match: '\\([\\)\s,\};\]])?'
      captures:
        0: string.quoted.single.livescript
      push:
        - meta_content_scope: string.quoted.single.livescript
        - match: '([\\)\s,\};\]])'
          captures:
            0: punctuation.definition.string.end.livescript
          pop: true
  constructor_variable:
    - match: '([a-zA-Z$_][\w$-]*)(@{2})([a-zA-Z$_][\w$-]*)?'
      scope: variable.other.readwrite.constructor.livescript
  double_quoted_string:
    - match: '"'
      captures:
        0: punctuation.definition.string.begin.livescript
      push:
        - meta_scope: string.quoted.double.livescript
        - match: '"'
          captures:
            0: punctuation.definition.string.end.livescript
          pop: true
        - match: '\\(x[0-9A-Fa-f]{2}|[0-2][0-7]{0,2}|3[0-6][0-7]|37[0-7]?|[4-7][0-7]?|.)'
          scope: constant.character.escape.livescript
        - include: interpolated_livescript
  embedded_comment:
    - match: (?<!\\)(#).*$\n
      scope: comment.line.number-sign.livescript
      captures:
        1: punctuation.definition.comment.livescript
  embedded_spaced_comment:
    - match: (?<!\\)(#\s).*$\n
      scope: comment.line.number-sign.livescript
      captures:
        1: punctuation.definition.comment.livescript
  instance_variable:
    - match: '(?<![$\w\-])(@)'
      scope: variable.other.readwrite.instance.livescript
  interpolated_livescript:
    - match: '\#\{'
      captures:
        0: punctuation.section.embedded.livescript
      push:
        - meta_scope: source.livescript.embedded.source
        - match: '\}'
          captures:
            0: punctuation.section.embedded.livescript
          pop: true
        - include: main
    - match: '\#'
      push:
        - meta_scope: source.livescript.embedded.source.simple
        - match: ""
          pop: true
        - include: main
  numeric:
    - match: '(?<![\$@a-zA-Z_])(([0-9]+r[0-9_]+)|((16r|0[xX])[0-9a-fA-F_]+)|([0-9]+(\.[0-9]+[0-9_]*)?(e[+\-]?[0-9_]+)?)[_a-zA-Z0-9]*)'
      scope: constant.numeric.livescript
  single_quoted_string:
    - match: "'"
      captures:
        0: punctuation.definition.string.begin.livescript
      push:
        - meta_scope: string.quoted.single.livescript
        - match: "'"
          captures:
            0: punctuation.definition.string.end.livescript
          pop: true
        - match: '\\(x[0-9A-Fa-f]{2}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.)'
          scope: constant.character.escape.livescript
  variable_name:
    - match: '([a-zA-Z\$_][\w$-]*(\.\w+)*)(?!\-)'
      scope: variable.assignment.livescript
      captures:
        1: variable.assignment.livescript
@@ -53,22 +53,39 @@ contexts:
      embed: synopsis
      escape: '(?={{section_heading}})'
    - match: '^(?:COMMANDS)\b'
      scope: markup.heading.commands.man
      embed: commands-start
      escape: '(?={{section_heading}})'
    - match: '^(?:ENVIRONMENT\s+VARIABLES)'
      scope: markup.heading.env.man
      embed: environment-variables
      escape: '(?={{section_heading}})'
    - match: '{{section_heading}}'
      scope: markup.heading.other.man
      embed: options # some man pages put command line options under the description heading
      escape: '(?={{section_heading}})'
  function-call:
-    - match: '\b([A-Za-z0-9_\-]+)(\()([^)]*)(\))'
+    - match: '\b([A-Za-z0-9_\-]+\.)?([A-Za-z0-9_\-]+)(\()([^)]*)(\))'
      captures:
        1: entity.name.function.man
-        2: keyword.operator.man
+        2: entity.name.function.man
-        3: constant.numeric.man
+        3: keyword.operator.man
-        4: keyword.operator.man
+        4: constant.numeric.man
        5: keyword.operator.man
  env-var:
    - match: '(\$)(?!\d)(\w+)\b'
      captures:
        1: punctuation.definition.variable.man
        2: constant.other.man
  options:
    # command-line options like --option=value, --some-flag, or -x
-    - match: '^[ ]{7}(?=-)'
+    - match: '^[ ]{7}(?=-|\+)'
      push: expect-command-line-option
    - match: '(?:[^a-zA-Z0-9_-]|^|\s){{command_line_option}}'
      captures:
@@ -86,9 +103,10 @@ contexts:
          pop: true
    - include: function-call
    - include: c-code
    - include: env-var
  expect-command-line-option:
-    - match: '[A-Za-z0-9-]+'
+    - match: '[A-Za-z0-9-\.\?:#\$\+]+'
      scope: entity.name.command-line-option.man
    - match: '(\[)(=)'
      captures:
@@ -114,7 +132,7 @@ contexts:
      pop: true
  expect-parameter:
-    - match: '[A-Za-z0-9-]+'
+    - match: '[A-Za-z0-9-_]+'
      scope: variable.parameter.man
    - match: (?=\s+\|)
      pop: true
@@ -127,6 +145,10 @@ contexts:
          scope: punctuation.section.brackets.end.man
          pop: true
        - include: expect-parameter
    - match: '<'
      scope: punctuation.definition.generic.begin.man
    - match: '>'
      scope: punctuation.definition.generic.end.man
    - match: '$|(?=[],]|{{command_line_option}})'
      pop: true
@@ -161,3 +183,20 @@ contexts:
    - match: \[
      scope: punctuation.section.brackets.begin.man
      push: command-line-option-or-pipe
  commands-start:
    - match: (?=^[ ]{7}.*(?:[ ]<|[|]))
      push: commands
  commands:
    - match: '^[ ]{7}([a-z_\-]+)(?=[ ]|$)'
      captures:
        1: entity.name.command.man
      push: expect-parameter
    - match: '^[ ]{7}(?=[\[<]|\w+[|\]])'
      push: expect-parameter
  environment-variables:
    - match: '^[ ]{7}([A-Z_]+)\b'
      captures:
        1: support.constant.environment-variable.man
@@ -5,6 +5,7 @@ name: Nim
 file_extensions:
  - nim
  - nims
  - nimble
 scope: source.nim
 contexts:
  main:
@@ -24,7 +24,7 @@ contexts:
    - include: commands
    - include: commentLine
    - include: variable
-    - include: interpolatedStringContent
+    - include: subexpression
    - include: function
    - include: attribute
    - include: UsingDirective
@@ -33,32 +33,38 @@ contexts:
    - include: doubleQuotedString
    - include: scriptblock
    - include: doubleQuotedStringEscapes
-    - match: (?<!')'
+    - match: '[''\x{2018}-\x{201B}]'
      captures:
        0: punctuation.definition.string.begin.powershell
      push:
        - meta_scope: string.quoted.single.powershell
-        - match: "'(?!')"
+        - match: '[''\x{2018}-\x{201B}]{2}'
          scope: constant.character.escape.powershell
        - match: '[''\x{2018}-\x{201B}]'
          captures:
            0: punctuation.definition.string.end.powershell
          pop: true
-        - match: "''"
+    - match: '(@["\x{201C}-\x{201E}])\s*$'
-          scope: constant.character.escape.powershell
+      captures:
-    - match: \@"(?=$)
+        1: punctuation.definition.string.begin.powershell
      push:
        - meta_scope: string.quoted.double.heredoc.powershell
-        - match: ^"@
+        - match: '^["\x{201C}-\x{201E}]@'
          captures:
            0: punctuation.definition.string.end.powershell
          pop: true
        - include: variableNoProperty
        - include: doubleQuotedStringEscapes
        - include: interpolation
-    - match: \@'(?=$)
+    - match: '(@[''\x{2018}-\x{201B}])\s*$'
      captures:
        1: punctuation.definition.string.begin.powershell
      push:
        - meta_scope: string.quoted.single.heredoc.powershell
-        - match: ^'@
+        - match: '^[''\x{2018}-\x{201B}]@'
          captures:
            0: punctuation.definition.string.end.powershell
          pop: true
        - match: "''"
          scope: constant.character.escape.powershell
    - include: numericConstant
    - match: (@)(\()
      captures:
@@ -71,11 +77,12 @@ contexts:
            0: punctuation.section.group.end.powershell
          pop: true
        - include: main
-    - match: (\$)(\()
+    - match: ((\$))(\()
      comment: "TODO: move to repo; make recursive."
      captures:
-        1: punctuation.definition.variable.powershell
+        1: keyword.other.substatement.powershell
-        2: punctuation.section.group.begin.powershell
+        2: punctuation.definition.subexpression.powershell
        3: punctuation.section.group.begin.powershell
      push:
        - meta_scope: meta.group.complex.subexpression.powershell
        - match: \)
@@ -85,7 +92,7 @@ contexts:
        - include: main
    - match: '(\b(([A-Za-z0-9\-_\.]+)\.(?i:exe|com|cmd|bat))\b)'
      scope: support.function.powershell
-    - match: (?<!\w|-|\.)((?i:begin|break|catch|continue|data|default|define|do|dynamicparam|else|elseif|end|exit|finally|for|from|if|in|inlinescript|parallel|param|process|return|sequence|switch|throw|trap|try|until|var|while)|%|\?)(?!\w)
+    - match: (?<!\w|-|\.)((?i:begin|break|catch|clean|continue|data|default|define|do|dynamicparam|else|elseif|end|exit|finally|for|from|if|in|inlinescript|parallel|param|process|return|sequence|switch|throw|trap|try|until|var|while)|%|\?)(?!\w)
      scope: keyword.control.powershell
    - match: '(?<!\w|-|[^\)]\.)((?i:(foreach|where)(?!-object))|%|\?)(?!\w)'
      scope: keyword.control.powershell
@@ -135,7 +142,7 @@ contexts:
        - meta_scope: meta.requires.powershell
        - match: $
          pop: true
-        - match: \-(?i:Modules|PSSnapin|RunAsAdministrator|ShellId|Version)
+        - match: \-(?i:Modules|PSSnapin|RunAsAdministrator|ShellId|Version|Assembly|PSEdition)
          scope: keyword.other.powershell
        - match: '(?<!-)\b\p{L}+|\d+(?:\.\d+)*'
          scope: variable.parameter.powershell
@@ -187,51 +194,53 @@ contexts:
      comment: Builtin cmdlets with reserved verbs
      scope: support.function.powershell
  commentEmbeddedDocs:
-    - match: ^(?i:(?:\s?|#)+(\.)(COMPONENT|DESCRIPTION|EXAMPLE|EXTERNALHELP|FORWARDHELPCATEGORY|FORWARDHELPTARGETNAME|FUNCTIONALITY|INPUTS|LINK|NOTES|OUTPUTS|REMOTEHELPRUNSPACE|ROLE|SYNOPSIS))
+    - match: (?:^|\G)(?i:\s*(\.)(COMPONENT|DESCRIPTION|EXAMPLE|FUNCTIONALITY|INPUTS|LINK|NOTES|OUTPUTS|ROLE|SYNOPSIS))\s*$
      comment: these embedded doc keywords do not support arguments, must be the only thing on the line
      scope: comment.documentation.embedded.powershell
      captures:
        1: constant.string.documentation.powershell
        2: keyword.operator.documentation.powershell
-    - match: '(?i:\s?(\.)(PARAMETER|FORWARDHELPTARGETNAME|FORWARDHELPCATEGORY|REMOTEHELPRUNSPACE|EXTERNALHELP)\s+([a-z0-9-_]+))'
+    - match: (?:^|\G)(?i:\s*(\.)(EXTERNALHELP|FORWARDHELP(?:CATEGORY|TARGETNAME)|PARAMETER|REMOTEHELPRUNSPACE))\s+(.+?)\s*$
      comment: these embedded doc keywords require arguments though the type required may be inconsistent, they may not all be able to use the same argument match
      scope: comment.documentation.embedded.powershell
      captures:
        1: constant.string.documentation.powershell
        2: keyword.operator.documentation.powershell
        3: keyword.operator.documentation.powershell
  commentLine:
-    - match: '(?<![`\\-])#'
+    - match: '(?<![`\\-])(#)#*'
      captures:
-        0: punctuation.definition.comment.powershell
+        1: punctuation.definition.comment.powershell
      push:
        - meta_scope: comment.line.powershell
        - match: $\n?
          captures:
-            0: punctuation.definition.comment.powershell
+            1: punctuation.definition.comment.powershell
          pop: true
        - include: commentEmbeddedDocs
        - include: RequiresDirective
  doubleQuotedString:
-    - match: (?<!(?<!`)")"
+    - match: '["\x{201C}-\x{201E}]'
      captures:
        0: punctuation.definition.string.begin.powershell
      push:
        - meta_scope: string.quoted.double.powershell
        - match: '"(?!")'
          captures:
            0: punctuation.definition.string.end.powershell
          pop: true
        - match: '(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,64}\b'
        - include: variableNoProperty
        - include: doubleQuotedStringEscapes
        - match: '["\x{201C}-\x{201E}]{2}'
          scope: constant.character.escape.powershell
        - include: interpolation
        - match: '`\s*$'
          scope: keyword.other.powershell
        - match: '["\x{201C}-\x{201E}]'
          captures:
            0: punctuation.definition.string.end.powershell
          pop: true
  doubleQuotedStringEscapes:
-    - match: '`[`0abefnrtv"''$]'
+    - match: '`[`0abefnrtv''"\x{2018}-\x{201E}$]'
      scope: constant.character.escape.powershell
    - include: unicodeEscape
    - match: '""'
      scope: constant.character.escape.powershell
  function:
    - match: '^(?:\s*+)(?i)(function|filter|configuration|workflow)\s+(?:(global|local|script|private):)?((?:\p{L}|\d|_|-|\.)+)'
      captures:
@@ -263,33 +272,23 @@ contexts:
            4: keyword.operator.assignment.powershell
        - include: scriptblock
        - include: main
  interpolatedStringContent:
    - match: \(
      captures:
        0: punctuation.section.group.begin.powershell
      push:
        - meta_content_scope: interpolated.simple.source.powershell
        - match: \)
          captures:
            0: punctuation.section.group.end.powershell
          pop: true
        - include: main
        - include: interpolation
        - include: interpolatedStringContent
  interpolation:
-    - match: (\$)(\()
+    - match: (((\$)))((\())
      captures:
-        1: punctuation.definition.variable.powershell
+        1: keyword.other.substatement.powershell
-        2: punctuation.section.group.begin.powershell
+        2: punctuation.definition.substatement.powershell
        3: punctuation.section.embedded.substatement.begin.powershell
        4: punctuation.section.group.begin.powershell
        5: punctuation.section.embedded.substatement.begin.powershell
      push:
        - meta_scope: meta.embedded.substatement.powershell
        - meta_content_scope: interpolated.complex.source.powershell
-        - match: \)
+        - match: (\))
          captures:
            0: punctuation.section.group.end.powershell
            1: punctuation.section.embedded.substatement.end.powershell
          pop: true
        - include: main
        - include: interpolation
        - include: interpolatedStringContent
  numericConstant:
    - match: '(?<!\w)([-+]?0(?:x|X)[0-9a-fA-F_]+(?:U|u|L|l|UL|Ul|uL|ul|LU|Lu|lU|lu)?)((?i:[kmgtp]b)?)\b'
      captures:
@@ -330,6 +329,17 @@ contexts:
            0: punctuation.section.braces.end.powershell
          pop: true
        - include: main
  subexpression:
    - match: \(
      captures:
        0: punctuation.section.group.begin.powershell
      push:
        - meta_scope: meta.group.simple.subexpression.powershell
        - match: \)
          captures:
            0: punctuation.section.group.end.powershell
          pop: true
        - include: main
  type:
    - match: '\['
      captures:
@@ -0,0 +1,52 @@
 %YAML 1.2
 ---
 # http://www.sublimetext.com/docs/3/syntax.html
 name: Racket
 file_extensions:
  - rkt
 scope: source.racket
 contexts:
  main:
    - match: '[^\\](\"[^\"]*\")'
      captures:
        1: string.quoted.double.source.racket
    - match: '\((define)\s+([a-zA-Z0-9_\-?\+^]+)\s*'
      scope: meta.variable.source.racket
      captures:
        1: keyword.source.racket
        2: entity.name.variable.source.racket
    - match: '\((define)\s+\(([a-zA-Z0-9_\-?\+^]+)\s*'
      scope: meta.function.source.racket
      captures:
        1: keyword.source.racket
        2: entity.name.function
    - match: '\((struct)\s+([a-zA-Z0-9_\-?\+^]+)\s+'
      scope: meta.struct.source.racket
      captures:
        1: keyword.source.racket
        2: entity.name.type
    - match: '[\s\(](if|lambda|cond|define|type-case|let|letrec|let!|\#lang|require|test|else|first|rest|define-type|define-type-alias|define-struct|not|local|error|lang)[\s\)]'
      scope: meta.keywords.source.racket
      captures:
        1: keyword.source.racket
    - match: '[\s\(](true|false|empty|null)[\s\)]'
      captures:
        1: constant.language.source.racket
    - match: '[\s\(\[\{](#t|#true|#f|#false)[\s\)\]\}]'
      captures:
        1: constant.language.source.racket
    - match: '(#\\[a-zA-Z0-9_\-?\+\.\!\"]+)'
      captures:
        1: constant.language.source.racket
    - match: '\b(0|([1-9][0-9_]*))\b'
      scope: constant.numeric.integer.source.racket
    - match: ;
      push:
        - meta_scope: comment.line.documentation.source.racket
        - match: $\n
          pop: true
    - match: '#\|'
      push:
        - meta_scope: comment.block.source.racket
        - match: '\|#'
          pop: true
@@ -0,0 +1,120 @@
 %YAML 1.2
 ---
 # http://www.sublimetext.com/docs/syntax.html
 name: Requirements.txt
 scope: source.requirements-txt
 # https://pip.pypa.io/en/stable/reference/requirements-file-format/
 # https://github.com/raimon49/requirements.txt.vim/blob/f246bd10155fbc3b1a9e2fff6c95b21521b09116/ftdetect/requirements.vim
 file_extensions:
  - requirements.txt
  - requirements.in
  - pip
 # https://github.com/sublimehq/Packages/pull/2760/files
 first_line_match: |-
  (?xi:
    ^ \#! .* \bpip                                        # shebang
  | ^ \s* \# .*? -\*- .*? \bpip-requirements\b .*? -\*-   # editorconfig
  | ^ \s* \# (vim?|ex): .*? \brequirements\b              # modeline
  )
 # pip install -r
 # pip-compile
 variables:
  operator: '===?|<=?|>=?|~=|!='
 contexts:
  main:
    - match: '(?i)\d+[\da-z\-_\.\*]*'
      scope: constant.other.version-control.requirements-txt
    - match: '(?i)^\[?--?[\da-z\-]*\]?'
      scope: entity.name.function.option.requirements-txt
    - match: '{{operator}}'
      scope: keyword.operator.logical.requirements-txt
    - match: '(\[)'
      captures:
        1: punctuation.section.braces.begin.requirements-txt
      push:
        - meta_scope: variable.function.extra.requirements-txt
        - match: ','
          scope: punctuation.separator.requirements-txt
        - match: '(\])'
          captures:
            1: punctuation.section.braces.end.requirements-txt
          pop: true
    - match: '(git\+?|hg\+|svn\+|bzr\+).*://.\S+'
      scope: markup.underline.link.versioncontrols.requirements-txt
    - match: '(@\s)?(https?|ftp|gopher)://?[^\s/$.?#].\S*'
      scope: markup.underline.link.url.requirements-txt
      captures:
        1: punctuation.definition.keyword.requirements-txt
    - match: '(?i)^[a-z\d_\-\.]*[a-z\d]'
      scope: variable.parameter.package-name.requirements-txt
    - match: '(;)'
      captures:
        1: punctuation.definition.annotation.requirements-txt
      push:
        - meta_scope: meta.annotation.requirements-txt
        # https://pip.pypa.io/en/stable/reference/inspect-report/#example
        - match: |-
            (?x:
              implementation_name
            | implementation_version
            | os_name
            | platform_machine
            | platform_release
            | platform_system
            | platform_version
            | python_full_version
            | platform_python_implementation
            | python_version
            | sys_platform
            )
          scope: variable.language.requirements-txt
        - match: '{{operator}}'
          scope: keyword.operator.logical.requirements-txt
          # https://pip.pypa.io/en/stable/reference/requirement-specifiers/#examples
        - match: '(")'
          captures:
            1: punctuation.definition.string.begin.double.requirements-txt
          push:
            - meta_scope: string.quoted.double.requirements-txt
            - match: '\\"'
              scope: constant.character.escape.double.requirements-txt
            - match: '(")'
              captures:
                1: punctuation.definition.string.end.double.requirements-txt
              pop: true
        - match: "(')"
          captures:
            1: punctuation.definition.string.begin.single.requirements-txt
          push:
            - meta_scope: string.quoted.single.requirements-txt
            - match: '\\'''
              scope: constant.character.escape.single.requirements-txt
            - match: "(')"
              captures:
                1: punctuation.definition.string.end.single.requirements-txt
              pop: true
        - match: '(.(?=#)|$)'
          pop: true
    - match: '(\$)(\{)'
      captures:
        1: punctuation.definition.keyword.requirements-txt
        2: punctuation.definition.begin.parameter.requirements-txt
      push:
        - meta_scope: variable.parameter.requirements-txt
        - match: '(\})'
          captures:
            1: punctuation.definition.end.parameter.requirements-txt
          pop: true
    - match: '(#)'
      captures:
        1: punctuation.definition.comment.requirements-txt
      push:
        - meta_scope: comment.line.requirements-txt
        - match: '(-*-) coding: .* (-*-)'
          captures:
            1: punctuation.definition.begin.pep263.requirements-txt
            2: punctuation.definition.end.pep263.requirements-txt
        - match: '$'
          pop: true
@@ -4,6 +4,7 @@
 name: Robot Framework
 file_extensions:
  - robot
  - resource
 scope: source.robot
 contexts:
  main:
@@ -0,0 +1,306 @@
 %YAML 1.2
 ---
 # http://www.sublimetext.com/docs/syntax.html
 name: Ruby Slim
 file_extensions:
  - slim
  - skim
 scope: text.slim
 contexts:
  main:
    - match: ^(\s*)(ruby):$
      captures:
        2: constant.language.name.ruby.filter.slim
      push:
        - meta_scope: text.ruby.filter.slim
        - match: ^(?!(\1\s)|\s*$)
          pop: true
        - include: scope:source.ruby
    - match: ^(\s*)(javascript):$
      captures:
        2: constant.language.name.javascript.filter.slim
      push:
        - meta_scope: source.js.filter.slim
        - match: ^(?!(\1\s)|\s*$)
          pop: true
        - include: scope:source.js
    - match: ^(---)\s*\n
      captures:
        1: storage.frontmatter.slim
      push:
        - meta_scope: source.yaml.meta.slim
        - match: ^(---)\s*\n
          captures:
            1: storage.frontmatter.slim
          pop: true
        - include: scope:source.yaml
    - match: ^(\s*)(coffee):$
      captures:
        2: constant.language.name.coffeescript.filter.slim
      push:
        - meta_scope: text.coffeescript.filter.slim
        - match: ^(?!(\1\s)|\s*$)
          pop: true
        - include: scope:source.coffee
    - match: ^(\s*)(markdown):$
      captures:
        2: constant.language.name.markdown.filter.slim
      push:
        - meta_scope: text.markdown.filter.slim
        - match: ^(?!(\1\s)|\s*$)
          pop: true
        - include: scope:text.html.markdown
    - match: ^(\s*)(css):$
      captures:
        2: constant.language.name.css.filter.slim
      push:
        - meta_scope: text.css.filter.slim
        - match: ^(?!(\1\s)|\s*$)
          pop: true
        - include: scope:source.css
    - match: ^(\s*)(sass):$
      captures:
        2: constant.language.name.sass.filter.slim
      push:
        - meta_scope: text.sass.filter.slim
        - match: ^(?!(\1\s)|\s*$)
          pop: true
        - include: scope:source.sass
    - match: ^(\s*)(scss):$
      captures:
        2: constant.language.name.scss.filter.slim
      push:
        - meta_scope: text.scss.filter.slim
        - match: ^(?!(\1\s)|\s*$)
          pop: true
        - include: scope:source.scss
    - match: ^(\s*)(less):$
      captures:
        2: constant.language.name.less.filter.slim
      push:
        - meta_scope: text.less.filter.slim
        - match: ^(?!(\1\s)|\s*$)
          pop: true
        - include: scope:source.less
    - match: ^(\s*)(erb):$
      captures:
        2: constant.language.name.erb.filter.slim
      push:
        - meta_scope: text.erb.filter.slim
        - match: ^(?!(\1\s)|\s*$)
          pop: true
        - include: scope:source.erb
    - match: ^(! )($|\s.*)
      scope: meta.prolog.slim
      captures:
        1: punctuation.definition.prolog.slim
    - match: ^(\s*)(/)\s*.*$
      captures:
        2: comment.line.slash.slim
      push:
        - meta_scope: comment.block.slim
        - match: ^(?!(\1\s)|\s*$)
          pop: true
    - match: ^\s*(?=-)
      push:
        - match: $
          pop: true
        - include: rubyline
    - match: (?==+|~)
      push:
        - match: $
          pop: true
        - include: rubyline
    - include: tag-attribute
    - include: embedded-ruby
    - match: ^(\s*)(\||')\s*
      comment: Verbatim text (can include HTML tags and copied lines)
      push:
        - match: ^(?!(\1\s)|\s*$)
          pop: true
        - include: scope:text.html.basic
        - include: embedded-ruby
    - match: '^\s*(\.|#|[-a-zA-Z0-9]+)([\w-]+)?'
      comment: '1 - dot OR hash OR any combination of word, number; 2 - OPTIONAL any combination of word, number, dash or underscore (following a . or'
      captures:
        1: entity.name.tag.slim
        2: entity.other.attribute-name.event.slim
      push:
        - meta_scope: meta.tag
        - match: '$|(?!\.|#|:|-|~|/|\}|\]|\*|\s?[\*\{])'
          captures:
            1: entity.name.tag.slim
            2: entity.other.attribute-name.event.slim
          pop: true
        - match: '(:[\w\d]+)+'
          comment: XML
          push:
            - meta_scope: entity.name.tag.slim
            - match: $|\s
              pop: true
        - match: '(:\s)(\.|#|[a-zA-Z0-9]+)([\w-]+)?'
          comment: Inline HTML / 1 - colon; 2 - dot OR hash OR any combination of word, number; 3 - OPTIONAL any combination of word, number, dash or underscore (following a . or
          captures:
            1: punctuation.definition.tag.end.slim
            2: entity.name.tag.slim
            3: entity.other.attribute-name.event.slim
          push:
            - match: '$|(?!\.|#|=|-|~|/|\}|\]|\*|\s?[\*\{])'
              captures:
                1: punctuation.definition.tag.end.slim
                2: entity.name.tag.slim
                3: entity.other.attribute-name.event.slim
              pop: true
            - include: root-class-id-tag
            - include: tag-attribute
        - match: '(\*\{)(?=.*\}|.*\|\s*$)'
          comment: Splat attributes
          captures:
            1: punctuation.section.embedded.ruby
          push:
            - meta_scope: source.ruby.embedded.slim
            - match: '(\})|$|^(?!.*\|\s*$)'
              captures:
                1: punctuation.section.embedded.ruby
              pop: true
            - include: embedded-ruby
        - include: root-class-id-tag
        - include: rubyline
        - match: /
          scope: punctuation.terminator.tag.slim
    - match: ^\s*(\\.)
      captures:
        1: meta.escape.slim
    - match: ^\s*(?=\||')
      push:
        - match: $
          pop: true
        - include: embedded-ruby
        - include: scope:text.html.basic
    - match: '(?=<[\w\d\:]+)'
      comment: Inline and root-level HTML tags
      push:
        - match: $|\/\>
          pop: true
        - include: scope:text.html.basic
  continuation:
    - match: '([\\,])\s*\n'
      captures:
        1: punctuation.separator.continuation.slim
  delimited-ruby-a:
    - match: '=\('
      push:
        - meta_scope: source.ruby.embedded.slim
        - match: \)(?=( \w|$))
          pop: true
        - include: scope:source.ruby.rails
  delimited-ruby-b:
    - match: '=\['
      push:
        - meta_scope: source.ruby.embedded.slim
        - match: '\](?=( \w|$))'
          pop: true
        - include: scope:source.ruby.rails
  delimited-ruby-c:
    - match: '=\{'
      push:
        - meta_scope: source.ruby.embedded.slim
        - match: '\}(?=( \w|$))'
          pop: true
        - include: scope:source.ruby.rails
  embedded-ruby:
    - match: '(?<!\\)#\{{1,2}'
      captures:
        0: punctuation.section.embedded.ruby
      push:
        - meta_scope: source.ruby.embedded.html
        - match: '\}{1,2}'
          captures:
            0: punctuation.section.embedded.ruby
          pop: true
        - include: scope:source.ruby.rails
  entities:
    - match: '(&)([a-zA-Z0-9]+|#[0-9]+|#x[0-9a-fA-F]+)(;)'
      scope: constant.character.entity.html
      captures:
        1: punctuation.definition.entity.html
        3: punctuation.definition.entity.html
    - match: '&'
      scope: invalid.illegal.bad-ampersand.html
  interpolated-ruby:
    - match: '=(?=\b)'
      push:
        - meta_scope: source.ruby.embedded.html
        - match: \s|\w$
          pop: true
  root-class-id-tag:
    - match: '(\.|#)([\w\d\-]+)'
      captures:
        1: punctuation.separator.key-value.html
        2: entity.other.attribute-name.html
  rubyline:
    - match: (==|=)(<>|><|<'|'<|<|>)?|-
      comment: Hack to thwart Sublime's Ruby highlighter. It thinks do without a variable continues the next line (this can be muted with a / at the end of the line). For things like yields, do is unnecessary without an argument, so this hack will suffice
      push:
        - meta_scope: meta.line.ruby.slim
        - meta_content_scope: source.ruby.embedded.slim
        - match: (do\s*\n$)|(?<!\\|,|,\n|\\\n)$
          captures:
            1: keyword.control.start-block.ruby
          pop: true
        - match: '#.*$'
          comment: Hack to let ruby comments work in this context properly
          scope: comment.line.number-sign.ruby
        - include: continuation
        - include: scope:source.ruby.rails
  string-double-quoted:
    - match: (")(?=.*")
      captures:
        0: punctuation.definition.string.begin.html
      push:
        - meta_scope: string.quoted.double.html
        - meta_content_scope: meta.toc-list.id.html
        - match: '"'
          captures:
            0: punctuation.definition.string.end.html
          pop: true
        - include: embedded-ruby
        - include: entities
  string-single-quoted:
    - match: (')(?=.*')
      captures:
        0: punctuation.definition.string.begin.html
      push:
        - meta_scope: string.quoted.single.html
        - meta_content_scope: meta.toc-list.id.html
        - match: "'"
          captures:
            0: punctuation.definition.string.end.html
          pop: true
        - include: embedded-ruby
        - include: entities
  tag-attribute:
    - match: '([\w.#_-]+)(=)(?!\s)(true|false|nil)?(\s*\(|\{)?'
      captures:
        1: entity.other.attribute-name.event.slim
        2: punctuation.separator.key-value.html
        3: constant.language.slim
      push:
        - meta_scope: meta.attribute-with-value.slim
        - match: '\}|\)|$'
          captures:
            1: entity.other.attribute-name.event.slim
            2: punctuation.separator.key-value.html
            3: constant.language.slim
          pop: true
        - include: tag-stuff
        - include: string-double-quoted
        - include: string-single-quoted
  tag-stuff:
    - include: tag-attribute
    - include: interpolated-ruby
    - include: delimited-ruby-a
    - include: delimited-ruby-b
    - include: delimited-ruby-c
    - include: rubyline
    - include: embedded-ruby
@@ -197,7 +197,7 @@ contexts:
          scope: entity.other.attribute-name.stylus
    - match: |-
        (?x)                # multi-line regex definition mode
-        (?<=^|;|{)\s*    # starts after begining of line, '{' or ';''
+        (?<=^|;|{)\s*    # starts after beginning of line, '{' or ';''
        (?=                 # lookahead for
            (
             [a-zA-Z0-9_-]  # then a letter
@@ -207,7 +207,7 @@ contexts:
             (/\*.*?\*/)    # comment
            )+
-            \s*[:\s]\s*     # value is separted by colon or space
+            \s*[:\s]\s*     # value is separated by colon or space
            (?!(\s*\{))     # if there are only spaces afterwards
@@ -4,6 +4,8 @@
 name: TypeScript
 file_extensions:
  - ts
  - mts
  - cts
 scope: source.ts
 contexts:
  main:
@@ -44,7 +46,7 @@ contexts:
        - match: (?=$)
          pop: true
  access-modifier:
-    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(abstract|public|protected|private|readonly|static|declare)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(abstract|declare|override|public|protected|private|readonly|static)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
      scope: storage.modifier.ts
  after-operator-block-as-object-literal:
    - match: '(?<!\+\+|--)(?<=[:=(,\[?+!>]|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^yield|[^\._$[:alnum:]]yield|^throw|[^\._$[:alnum:]]throw|^in|[^\._$[:alnum:]]in|^of|[^\._$[:alnum:]]of|^typeof|[^\._$[:alnum:]]typeof|&&|\|\||\*)\s*(\{)'
@@ -106,7 +108,7 @@ contexts:
          (?=
            # sure shot arrow functions even if => is on new line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
          [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
          (
            ([)]\s*:) |                                                                                       # ():
@@ -116,9 +118,9 @@ contexts:
        # arrow function possible to detect only with => on same line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
-          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
          \s*=>                                                                                               # arrow operator
        )
          )
@@ -268,7 +270,7 @@ contexts:
        - include: decorator
        - match: (?<=:)\s*
          push:
-            - match: '(?=\s|[;),}\]:\-\+]|;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
+            - match: '(?=\s|[;),}\]:\-\+]|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
              pop: true
            - include: expression
        - include: method-declaration
@@ -317,7 +319,12 @@ contexts:
    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(break|continue|do|goto|while)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
      scope: keyword.control.loop.ts
    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(return)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
-      scope: keyword.control.flow.ts
+      captures:
        0: keyword.control.flow.ts
      push:
        - match: '(?=[;}]|$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
          pop: true
        - include: expression
    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default|switch)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
      scope: keyword.control.switch.ts
    - include: if-statement
@@ -762,7 +769,7 @@ contexts:
        4: keyword.control.default.ts
      push:
        - meta_scope: meta.export.default.ts
-        - match: (?=$|;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))
+        - match: (?=$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))
          pop: true
        - include: interface-declaration
        - include: expression
@@ -772,7 +779,7 @@ contexts:
        2: keyword.control.type.ts
      push:
        - meta_scope: meta.export.ts
-        - match: (?=$|;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))
+        - match: (?=$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))
          pop: true
        - include: import-export-declaration
  expression:
@@ -785,11 +792,11 @@ contexts:
    - include: string
    - include: decorator
    - include: destructuring-parameter
-    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(public|protected|private|readonly)\s+(?=(public|protected|private|readonly)\s+)'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|protected|private|readonly)\s+(?=(override|public|protected|private|readonly)\s+)'
      captures:
        1: storage.modifier.ts
    - match: |-
-        (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s*
+        (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s*
        # function assignment |
        (=\s*(
          ((async\s+)?(
@@ -798,10 +805,10 @@ contexts:
            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
          )) |
          ((async\s*)?(
-            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
+            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
            # sure shot arrow functions even if => is on new line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
          [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
          (
            ([)]\s*:) |                                                                                       # ():
@@ -811,9 +818,9 @@ contexts:
        # arrow function possible to detect only with => on same line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
-          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
          \s*=>                                                                                               # arrow operator
        )
          ))
@@ -831,18 +838,18 @@ contexts:
          ))
        )) |
        (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |
-        (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
+        (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
-        (:\s*(=>|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
+        (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
          ((async\s+)?(
            (function\s*[(<*]) |
            (function\s+) |
            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
          )) |
          ((async\s*)?(
-            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
+            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
            # sure shot arrow functions even if => is on new line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
          [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
          (
            ([)]\s*:) |                                                                                       # ():
@@ -852,9 +859,9 @@ contexts:
        # arrow function possible to detect only with => on same line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
-          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
          \s*=>                                                                                               # arrow operator
        )
          ))
@@ -865,7 +872,7 @@ contexts:
        3: entity.name.function.ts variable.language.this.ts
        4: entity.name.function.ts
        5: keyword.operator.optional.ts
-    - match: '(?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s*[:,]|$)'
+    - match: '(?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s*[:,]|$)'
      captures:
        1: storage.modifier.ts
        2: keyword.operator.rest.ts
@@ -930,10 +937,11 @@ contexts:
      scope: keyword.operator.comparison.ts
    - match: <=|>=|<>|<|>
      scope: keyword.operator.relational.ts
-    - match: '(?<=[_$[:alnum:]])(\!)\s*(/)(?![/*])'
+    - match: '(?<=[_$[:alnum:]])(\!)\s*(?:(/=)|(?:(/)(?![/*])))'
      captures:
        1: keyword.operator.logical.ts
-        2: keyword.operator.arithmetic.ts
+        2: keyword.operator.assignment.compound.ts
        3: keyword.operator.arithmetic.ts
    - match: \!|&&|\|\||\?\?
      scope: keyword.operator.logical.ts
    - match: \&|~|\^|\|
@@ -946,16 +954,18 @@ contexts:
      scope: keyword.operator.increment.ts
    - match: '%|\*|/|-|\+'
      scope: keyword.operator.arithmetic.ts
-    - match: '(?<=[_$[:alnum:])\]])\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)+(/)(?![/*]))'
+    - match: '(?<=[_$[:alnum:])\]])\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)+(?:(/=)|(?:(/)(?![/*]))))'
      push:
-        - match: '(/)(?!\*([^\*]|(\*[^\/]))*\*\/)'
+        - match: '(?:(/=)|(?:(/)(?!\*([^\*]|(\*[^\/]))*\*\/)))'
          captures:
-            1: keyword.operator.arithmetic.ts
+            1: keyword.operator.assignment.compound.ts
            2: keyword.operator.arithmetic.ts
          pop: true
        - include: comment
-    - match: '(?<=[_$[:alnum:])\]])\s*(/)(?![/*])'
+    - match: '(?<=[_$[:alnum:])\]])\s*(?:(/=)|(?:(/)(?![/*])))'
      captures:
-        1: keyword.operator.arithmetic.ts
+        1: keyword.operator.assignment.compound.ts
        2: keyword.operator.arithmetic.ts
  expressionPunctuations:
    - include: punctuation-comma
    - include: punctuation-accessor
@@ -1021,10 +1031,10 @@ contexts:
                ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
              )) |
              ((async\s*)?(
-                ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
+                ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
                # sure shot arrow functions even if => is on new line
            (
-              (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
+              (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
              [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
              (
                ([)]\s*:) |                                                                                       # ():
@@ -1034,9 +1044,9 @@ contexts:
            # arrow function possible to detect only with => on same line
            (
-              (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+              (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
-              \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+              \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-              (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+              (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
              \s*=>                                                                                               # arrow operator
            )
              ))
@@ -1054,18 +1064,18 @@ contexts:
              ))
            )) |
            (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |
-            (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
+            (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
-            (:\s*(=>|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
+            (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
              ((async\s+)?(
                (function\s*[(<*]) |
                (function\s+) |
                ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
              )) |
              ((async\s*)?(
-                ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
+                ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
                # sure shot arrow functions even if => is on new line
            (
-              (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
+              (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
              [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
              (
                ([)]\s*:) |                                                                                       # ():
@@ -1075,9 +1085,9 @@ contexts:
            # arrow function possible to detect only with => on same line
            (
-              (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+              (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
-              \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+              \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-              (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+              (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
              \s*=>                                                                                               # arrow operator
            )
              ))
@@ -1118,18 +1128,19 @@ contexts:
    - include: type-parameters
    - include: function-parameters
    - include: return-type
    - include: type-function-return-type
    - include: decl-block
    - match: \*
      scope: keyword.generator.asterisk.ts
  function-call:
-    - match: '(?=(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\())'
+    - match: '(?=(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\())'
      push:
-        - match: '(?<=\))(?!(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\())'
+        - match: '(?<=\))(?!(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\())'
          pop: true
        - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))'
          push:
            - meta_scope: meta.function-call.ts
-            - match: '(?=\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\())'
+            - match: '(?=\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\())'
              pop: true
            - include: function-call-target
        - include: comment
@@ -1169,7 +1180,7 @@ contexts:
        6: meta.definition.function.ts entity.name.function.ts
      push:
        - meta_scope: meta.function.ts
-        - match: '(?=;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))|(?<=\})'
+        - match: '(?=;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))|(?<=\})'
          pop: true
        - include: function-name
        - include: function-body
@@ -1221,10 +1232,10 @@ contexts:
            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
          )) |
          ((async\s*)?(
-            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
+            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
            # sure shot arrow functions even if => is on new line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
          [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
          (
            ([)]\s*:) |                                                                                       # ():
@@ -1234,9 +1245,9 @@ contexts:
        # arrow function possible to detect only with => on same line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
-          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
          \s*=>                                                                                               # arrow operator
        )
          ))
@@ -1260,7 +1271,7 @@ contexts:
    - match: "[_$[:alpha:]][_$[:alnum:]]*"
      scope: variable.other.readwrite.ts
  if-statement:
-    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bif\s*(\(([^\(\)]|(\([^\(\)]*\)))*\))\s*(?!\{))'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bif\s*(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))\s*(?!\{))'
      push:
        - match: '(?=;|$|\})'
          pop: true
@@ -1275,12 +1286,12 @@ contexts:
                0: meta.brace.round.ts
              pop: true
            - include: expression
-        - match: '(?<=\))\s*\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/([gimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'
+        - match: '(?<=\))\s*\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'
          captures:
            0: punctuation.definition.string.begin.ts
          push:
            - meta_scope: string.regexp.ts
-            - match: "(/)([gimsuy]*)"
+            - match: "(/)([dgimsuy]*)"
              captures:
                1: punctuation.definition.string.end.ts
                2: keyword.other.ts
@@ -1414,6 +1425,9 @@ contexts:
            2: keyword.operator.type.modifier.ts
            3: keyword.operator.optional.ts
          pop: true
        - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+'
          captures:
            1: keyword.control.as.ts
        - include: type
  inline-tags:
    - match: '(\[)[^\]]+(\])(?={@(?:link|linkcode|linkplain|tutorial))'
@@ -1504,25 +1518,27 @@ contexts:
    - include: this-literal
    - include: super-literal
  method-declaration:
-    - match: '(?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?\s*\b(constructor)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
+    - match: '(?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?\s*\b(constructor)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
      captures:
        1: storage.modifier.ts
        2: storage.modifier.ts
-        3: storage.modifier.async.ts
+        3: storage.modifier.ts
-        4: storage.type.ts
+        4: storage.modifier.async.ts
        5: storage.type.ts
      push:
        - meta_scope: meta.method.declaration.ts
        - match: '(?=\}|;|,|$)|(?<=\})'
          pop: true
        - include: method-declaration-name
        - include: function-body
-    - match: '(?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:(?:\s*\b(new)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|(?:(\*)\s*)?)(?=\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])'
+    - match: '(?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:(?:\s*\b(new)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|(?:(\*)\s*)?)(?=\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])'
      captures:
        1: storage.modifier.ts
        2: storage.modifier.ts
-        3: storage.modifier.async.ts
+        3: storage.modifier.ts
-        4: keyword.operator.new.ts
+        4: storage.modifier.async.ts
-        5: keyword.generator.asterisk.ts
+        5: keyword.operator.new.ts
        6: keyword.generator.asterisk.ts
      push:
        - meta_scope: meta.method.declaration.ts
        - match: '(?=\}|;|,|$)|(?<=\})'
@@ -1530,7 +1546,7 @@ contexts:
        - include: method-declaration-name
        - include: function-body
    - match: |-
-        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=\s*(((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?:
+        (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=\s*(((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?:
          (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3
          (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)|             # 1.E+3
          (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)|             # .1E+3
@@ -1539,13 +1555,14 @@ contexts:
          (?:\b[0-9][0-9_]*(\.)(n)?\B)|                                  # 1.
          (?:\B(\.)[0-9][0-9_]*(n)?\b)|                                  # .1
          (?:\b[0-9][0-9_]*(n)?\b(?!\.))                                 # 1
-        )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])
+        )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])
      captures:
        1: storage.modifier.ts
        2: storage.modifier.ts
-        3: storage.modifier.async.ts
+        3: storage.modifier.ts
-        4: storage.type.property.ts
+        4: storage.modifier.async.ts
-        5: keyword.generator.asterisk.ts
+        5: storage.type.property.ts
        6: keyword.generator.asterisk.ts
      push:
        - meta_scope: meta.method.declaration.ts
        - match: '(?=\}|;|,|$)|(?<=\})'
@@ -1582,7 +1599,7 @@ contexts:
        3: storage.type.namespace.ts
      push:
        - meta_scope: meta.namespace.declaration.ts
-        - match: '(?<=\})|(?=;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
+        - match: '(?<=\})|(?=;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
          pop: true
        - include: comment
        - include: string
@@ -1598,9 +1615,7 @@ contexts:
        - meta_scope: new.expr.ts
        - match: '(?<=\))|(?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(]))))'
          pop: true
-        - include: paren-expression
+        - include: expression
        - include: class-declaration
        - include: type
  null-literal:
    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))null(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
      scope: constant.language.null.ts
@@ -1781,7 +1796,7 @@ contexts:
          (?:\b[0-9][0-9_]*(\.)(n)?\B)|                                  # 1.
          (?:\B(\.)[0-9][0-9_]*(n)?\b)|                                  # .1
          (?:\b[0-9][0-9_]*(n)?\b(?!\.))                                 # 1
-        )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])
+        )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])
      captures:
        1: storage.modifier.async.ts
        2: storage.type.property.ts
@@ -1802,7 +1817,7 @@ contexts:
              (?:\b[0-9][0-9_]*(\.)(n)?\B)|                                  # 1.
              (?:\B(\.)[0-9][0-9_]*(n)?\b)|                                  # .1
              (?:\b[0-9][0-9_]*(n)?\b(?!\.))                                 # 1
-            )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])
+            )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])
          captures:
            1: storage.modifier.async.ts
            2: storage.type.property.ts
@@ -1864,10 +1879,10 @@ contexts:
            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
          )) |
          ((async\s*)?(
-            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
+            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
            # sure shot arrow functions even if => is on new line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
          [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
          (
            ([)]\s*:) |                                                                                       # ():
@@ -1877,9 +1892,9 @@ contexts:
        # arrow function possible to detect only with => on same line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
-          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
          \s*=>                                                                                               # arrow operator
        )
          ))
@@ -1930,7 +1945,7 @@ contexts:
        - meta_scope: meta.object.member.ts
        - match: '(?=,|\})'
          pop: true
-        - match: '(?<=:)\s*(async)?(?=\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'
+        - match: '(?<=:)\s*(async)?(?=\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'
          captures:
            1: storage.modifier.async.ts
          push:
@@ -1946,7 +1961,7 @@ contexts:
                    0: meta.brace.round.ts
                  pop: true
                - include: expression-inside-possibly-arrow-parens
-        - match: '(?<=:)\s*(async)?\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'
+        - match: '(?<=:)\s*(async)?\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'
          captures:
            1: storage.modifier.async.ts
            2: meta.brace.round.ts
@@ -1963,7 +1978,7 @@ contexts:
            - match: (?<=\>)
              pop: true
            - include: type-parameters
-        - match: '(?<=\>)\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'
+        - match: '(?<=\>)\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'
          captures:
            1: meta.brace.round.ts
          push:
@@ -1997,11 +2012,11 @@ contexts:
    - include: destructuring-parameter-rest
    - include: variable-initializer
  parameter-name:
-    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(public|protected|private|readonly)\s+(?=(public|protected|private|readonly)\s+)'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|protected|private|readonly)\s+(?=(override|public|protected|private|readonly)\s+)'
      captures:
        1: storage.modifier.ts
    - match: |-
-        (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s*
+        (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s*
        # function assignment |
        (=\s*(
          ((async\s+)?(
@@ -2010,10 +2025,10 @@ contexts:
            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
          )) |
          ((async\s*)?(
-            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
+            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
            # sure shot arrow functions even if => is on new line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
          [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
          (
            ([)]\s*:) |                                                                                       # ():
@@ -2023,9 +2038,9 @@ contexts:
        # arrow function possible to detect only with => on same line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
-          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
          \s*=>                                                                                               # arrow operator
        )
          ))
@@ -2043,18 +2058,18 @@ contexts:
          ))
        )) |
        (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |
-        (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
+        (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
-        (:\s*(=>|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
+        (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
          ((async\s+)?(
            (function\s*[(<*]) |
            (function\s+) |
            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
          )) |
          ((async\s*)?(
-            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
+            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
            # sure shot arrow functions even if => is on new line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
          [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
          (
            ([)]\s*:) |                                                                                       # ():
@@ -2064,9 +2079,9 @@ contexts:
        # arrow function possible to detect only with => on same line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
-          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
          \s*=>                                                                                               # arrow operator
        )
          ))
@@ -2077,7 +2092,7 @@ contexts:
        3: entity.name.function.ts variable.language.this.ts
        4: entity.name.function.ts
        5: keyword.operator.optional.ts
-    - match: '(?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)'
+    - match: '(?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)'
      captures:
        1: storage.modifier.ts
        2: keyword.operator.rest.ts
@@ -2137,14 +2152,14 @@ contexts:
          pop: true
        - include: expression
  paren-expression-possibly-arrow:
-    - match: '(?<=[(=,])\s*(async)?(?=\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'
+    - match: '(?<=[(=,])\s*(async)?(?=\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'
      captures:
        1: storage.modifier.async.ts
      push:
        - match: (?<=\))
          pop: true
        - include: paren-expression-possibly-arrow-with-typeparameters
-    - match: '(?<=[(=,]|=>|^return|[^\._$[:alnum:]]return)\s*(async)?(?=\s*((((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\()|(<))\s*$)'
+    - match: '(?<=[(=,]|=>|^return|[^\._$[:alnum:]]return)\s*(async)?(?=\s*((((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\()|(<))\s*$)'
      captures:
        1: storage.modifier.async.ts
      push:
@@ -2164,7 +2179,7 @@ contexts:
          pop: true
        - include: expression-inside-possibly-arrow-parens
  possibly-arrow-return-type:
-    - match: '(?<=\)|^)\s*(:)(?=\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*=>)'
+    - match: '(?<=\)|^)\s*(:)(?=\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*=>)'
      captures:
        1: meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts
      push:
@@ -2211,23 +2226,23 @@ contexts:
          pop: true
        - include: string-character-escape
  regex:
-    - match: '(?<!\+\+|--|})(?<=[=(:,\[?+!]|^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[\()]|\\.|\[([^\]\\]|\\.)+\]|\(([^\)\\]|\\.)+\))+\/([gimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'
+    - match: '(?<!\+\+|--|})(?<=[=(:,\[?+!]|^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[\()]|\\.|\[([^\]\\]|\\.)+\]|\(([^\)\\]|\\.)+\))+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'
      captures:
        1: punctuation.definition.string.begin.ts
      push:
        - meta_scope: string.regexp.ts
-        - match: "(/)([gimsuy]*)"
+        - match: "(/)([dgimsuy]*)"
          captures:
            1: punctuation.definition.string.end.ts
            2: keyword.other.ts
          pop: true
        - include: regexp
-    - match: '((?<![_$[:alnum:])\]]|\+\+|--|}|\*\/)|((?<=^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case))\s*)\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/([gimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'
+    - match: '((?<![_$[:alnum:])\]]|\+\+|--|}|\*\/)|((?<=^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case))\s*)\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'
      captures:
        0: punctuation.definition.string.begin.ts
      push:
        - meta_scope: string.regexp.ts
-        - match: "(/)([gimsuy]*)"
+        - match: "(/)([dgimsuy]*)"
          captures:
            1: punctuation.definition.string.end.ts
            2: keyword.other.ts
@@ -2430,7 +2445,7 @@ contexts:
        4: support.variable.property.target.ts
    - match: |-
        (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?:
-        (?:(constructor|length|prototype|__proto__)\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\())
+        (?:(constructor|length|prototype|__proto__)\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\())
        |
        (?:(EPSILON|MAX_SAFE_INTEGER|MAX_VALUE|MIN_SAFE_INTEGER|MIN_VALUE|NEGATIVE_INFINITY|POSITIVE_INFINITY)\b(?!\$)))
      captures:
@@ -2536,7 +2551,7 @@ contexts:
        |siblingBelow|size|source|specified|standby|start|status|statusbar|statusText|style|styleSheets|suffixes|summary
        |systemId|systemLanguage|tagName|tags|target|tBodies|text|textAlign|textDecoration|textIndent|textTransform|tFoot|tHead
        |title|toolbar|top|type|undefined|uniqueID|updateInterval|URL|URLUnencoded|useMap|userAgent|userLanguage|userProfile
-        |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\()
+        |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\()
      captures:
        1: punctuation.accessor.ts
        2: punctuation.accessor.optional.ts
@@ -2703,27 +2718,7 @@ contexts:
                0: case-clause.expr.ts punctuation.definition.section.case-statement.ts
            - include: statements
  template:
-    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)(<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?`)'
+    - include: template-call
      push:
        - meta_scope: string.template.ts
        - match: (?=`)
          pop: true
        - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*))'
          push:
            - match: '(?=(<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?`)'
              pop: true
            - include: support-function-call-identifiers
            - match: "([_$[:alpha:]][_$[:alnum:]]*)"
              scope: entity.name.function.tagged-template.ts
        - include: type-arguments
    - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?=(<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|awaited|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)`)'
      captures:
        1: entity.name.function.tagged-template.ts
      push:
        - meta_scope: string.template.ts
        - match: (?=`)
          pop: true
        - include: type-arguments
    - match: "([_$[:alpha:]][_$[:alnum:]]*)?(`)"
      captures:
        1: entity.name.function.tagged-template.ts
@@ -2736,6 +2731,28 @@ contexts:
          pop: true
        - include: template-substitution-element
        - include: string-character-escape
  template-call:
    - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?`)'
      push:
        - meta_scope: string.template.ts
        - match: (?=`)
          pop: true
        - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*))'
          push:
            - match: '(?=(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?`)'
              pop: true
            - include: support-function-call-identifiers
            - match: "([_$[:alpha:]][_$[:alnum:]]*)"
              scope: entity.name.function.tagged-template.ts
        - include: type-arguments
    - match: '([_$[:alpha:]][_$[:alnum:]]*)?\s*(?=(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)`)'
      captures:
        1: entity.name.function.tagged-template.ts
      push:
        - meta_scope: string.template.ts
        - match: (?=`)
          pop: true
        - include: type-arguments
  template-substitution-element:
    - match: '\$\{'
      captures:
@@ -2748,6 +2765,32 @@ contexts:
            0: punctuation.definition.template-expression.end.ts
          pop: true
        - include: expression
  template-type:
    - include: template-call
    - match: "([_$[:alpha:]][_$[:alnum:]]*)?(`)"
      captures:
        1: entity.name.function.tagged-template.ts
        2: punctuation.definition.string.template.begin.ts
      push:
        - meta_scope: string.template.ts
        - match: "`"
          captures:
            0: punctuation.definition.string.template.end.ts
          pop: true
        - include: template-type-substitution-element
        - include: string-character-escape
  template-type-substitution-element:
    - match: '\$\{'
      captures:
        0: punctuation.definition.template-expression.begin.ts
      push:
        - meta_scope: meta.template.expression.ts
        - meta_content_scope: meta.embedded.line.ts
        - match: '\}'
          captures:
            0: punctuation.definition.template-expression.end.ts
          pop: true
        - include: type
  ternary-expression:
    - match: '(?!\?\.\s*[^[:digit:]])(\?)(?!\?)'
      captures:
@@ -2763,7 +2806,7 @@ contexts:
      scope: variable.language.this.ts
  type:
    - include: comment
-    - include: string
+    - include: type-string
    - include: numeric-literal
    - include: type-primitive
    - include: type-builtin-literals
@@ -2788,15 +2831,23 @@ contexts:
        4: entity.name.type.alias.ts
      push:
        - meta_scope: meta.type.declaration.ts
-        - match: '(?=\}|;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
+        - match: '(?=\}|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
          pop: true
        - include: comment
        - include: type-parameters
        - match: '(=)\s*(intrinsic)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
          captures:
            1: keyword.operator.assignment.ts
            2: keyword.control.intrinsic.ts
          push:
            - match: '(?=\}|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
              pop: true
            - include: type
        - match: (=)\s*
          captures:
            1: keyword.operator.assignment.ts
          push:
-            - match: '(?=\}|;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
+            - match: '(?=\}|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
              pop: true
            - include: type
  type-annotation:
@@ -2854,17 +2905,19 @@ contexts:
            - include: type
        - include: type
  type-fn-type-parameters:
-    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\b(?=\s*\<)'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(new)\b(?=\s*\<)'
      captures:
-        1: meta.type.constructor.ts keyword.control.new.ts
+        1: meta.type.constructor.ts storage.modifier.ts
        2: meta.type.constructor.ts keyword.control.new.ts
      push:
        - match: (?<=>)
          pop: true
        - include: comment
        - include: type-parameters
-    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\b\s*(?=\()'
+    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(new)\b\s*(?=\()'
      captures:
-        1: keyword.control.new.ts
+        1: storage.modifier.ts
        2: keyword.control.new.ts
      push:
        - meta_scope: meta.type.constructor.ts
        - match: (?<=\))
@@ -2993,8 +3046,6 @@ contexts:
      scope: keyword.operator.ternary.ts
    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))infer(?=\s+[_$[:alpha:]])'
      scope: keyword.operator.expression.infer.ts
    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))awaited(?=\s+[_$[:alpha:]])'
      scope: keyword.operator.expression.awaited.ts
    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*\()'
      scope: keyword.operator.expression.import.ts
  type-parameters:
@@ -3037,7 +3088,7 @@ contexts:
              ))
            )) |
            (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |
-            (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))))
+            (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))))
          captures:
            1: storage.modifier.ts
            2: keyword.operator.rest.ts
@@ -3074,6 +3125,10 @@ contexts:
  type-primitive:
    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(string|number|bigint|boolean|symbol|any|void|never|unknown)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
      scope: support.type.primitive.ts
  type-string:
    - include: qstring-single
    - include: qstring-double
    - include: template-type
  type-tuple:
    - match: '\['
      captures:
@@ -3095,7 +3150,12 @@ contexts:
        - include: punctuation-comma
  typeof-operator:
    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))typeof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
-      scope: keyword.operator.expression.typeof.ts
+      captures:
        0: keyword.operator.expression.typeof.ts
      push:
        - match: '(?=[,);}\]=>:&|{\?]|$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
          pop: true
        - include: expression
  undefined-literal:
    - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))undefined(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
      scope: constant.language.undefined.ts
@@ -3103,7 +3163,7 @@ contexts:
    - match: '(?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))'
      push:
        - meta_scope: meta.var.expr.ts
-        - match: '(?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$|;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))|((?<!^let|[^\._$[:alnum:]]let|^var|[^\._$[:alnum:]]var)(?=\s*$)))'
+        - match: '(?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))|((?<!^let|[^\._$[:alnum:]]let|^var|[^\._$[:alnum:]]var)(?=\s*$)))'
          pop: true
        - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*'
          captures:
@@ -3136,7 +3196,7 @@ contexts:
        3: storage.type.ts
      push:
        - meta_scope: meta.var.expr.ts
-        - match: '(?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$|;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))|((?<!^const|[^\._$[:alnum:]]const)(?=\s*$)))'
+        - match: '(?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))|((?<!^const|[^\._$[:alnum:]]const)(?=\s*$)))'
          pop: true
        - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*'
          captures:
@@ -3173,10 +3233,10 @@ contexts:
            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
          )) |
          ((async\s*)?(
-            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
+            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
            # sure shot arrow functions even if => is on new line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
          [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
          (
            ([)]\s*:) |                                                                                       # ():
@@ -3186,9 +3246,9 @@ contexts:
        # arrow function possible to detect only with => on same line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
-          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
          \s*=>                                                                                               # arrow operator
        )
          ))
@@ -3206,18 +3266,18 @@ contexts:
          ))
        )) |
        (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |
-        (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
+        (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
-        (:\s*(=>|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
+        (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
          ((async\s+)?(
            (function\s*[(<*]) |
            (function\s+) |
            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
          )) |
          ((async\s*)?(
-            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
+            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
            # sure shot arrow functions even if => is on new line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
          [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
          (
            ([)]\s*:) |                                                                                       # ():
@@ -3227,9 +3287,9 @@ contexts:
        # arrow function possible to detect only with => on same line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
-          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
          \s*=>                                                                                               # arrow operator
        )
          ))
@@ -3260,10 +3320,10 @@ contexts:
            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
          )) |
          ((async\s*)?(
-            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
+            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
            # sure shot arrow functions even if => is on new line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
          [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
          (
            ([)]\s*:) |                                                                                       # ():
@@ -3273,9 +3333,9 @@ contexts:
        # arrow function possible to detect only with => on same line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
-          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
          \s*=>                                                                                               # arrow operator
        )
          ))
@@ -3293,18 +3353,18 @@ contexts:
          ))
        )) |
        (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |
-        (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
+        (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
-        (:\s*(=>|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
+        (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
          ((async\s+)?(
            (function\s*[(<*]) |
            (function\s+) |
            ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
          )) |
          ((async\s*)?(
-            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
+            ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
            # sure shot arrow functions even if => is on new line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
          [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
          (
            ([)]\s*:) |                                                                                       # ():
@@ -3314,9 +3374,9 @@ contexts:
        # arrow function possible to detect only with => on same line
        (
-          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
-          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
          \s*=>                                                                                               # arrow operator
        )
          ))
@@ -0,0 +1,104 @@
 %YAML 1.2
 ---
 # http://www.sublimetext.com/docs/syntax.html
 scope: source.vimhelp
 file_extensions:
  # shortname
  - vimhelp
 # $VIMRUNTIME/syntax/help.vim
 contexts:
  main:
    - match: '(?<=^\s*)(vim?|ex):\s*([a-z]+(=[^\s:]+)?(\s+|:))+'
      scope: comment.line.modeline.vimhelp
    - match: '^[-A-Z .][-A-Z0-9 .()_]*(?=\s+\*|$)'
      scope: markup.heading.headline.vimhelp
    - match: '^(===.*===)$'
      captures:
        1: punctuation.definition.heading.1.setext.vimhelp
      push:
        - meta_scope: markup.heading.1.setext.vimhelp
        - match: '\t|  '
          pop: true
    - match: '^(---.*---)$'
      captures:
        1: punctuation.definition.heading.2.setext.vimhelp
      push:
        - meta_scope: markup.heading.2.setext.vimhelp
        - match: '\t|  '
          pop: true
    - match: '(?:^| )(>)$'
      captures:
        1: punctuation.definition.blockquote.begin.vimhelp
      push:
        - meta_scope: markup.quote.vimhelp
        - match: '^(<)'
          captures:
            1: punctuation.definition.blockquote.end.vimhelp
          pop: true
        - match: '^(?=\S)'
          pop: true
    - match: '(?<!\\)(\|)([#-)!+-~]+)(\|)'
      captures:
        1: punctuation.definition.link.begin.vimhelp
        2: markup.underline.link.vimhelp
        3: punctuation.definition.link.end.vimhelp
    - match: '(\*)([#-)!+-~]+)(\*)(?:\s|$)'
      captures:
        1: punctuation.definition.constant.begin.vimhelp
        2: entity.name.reference.link.vimhelp
        3: punctuation.definition.constant.end.vimhelp
    - match: '\bVim version [0-9][0-9.a-z]*'
      scope: variable.language.vimhelp
    - match: 'N?VIM REFERENCE.*'
      scope: variable.language.vimhelp
    - match: '('')([a-z]{2,}|t_..)('')'
      captures:
        1: punctuation.definition.link.option.begin.vimhelp
        2: markup.underline.link.option.vimhelp
        3: punctuation.definition.link.option.end.vimhelp
    - match: '(`)([^` \t]+)(`)'
      captures:
        1: punctuation.definition.link.command.begin.vimhelp
        2: markup.underline.link.command.vimhelp
        3: punctuation.definition.link.command.end.vimhelp
    - match: '(?<=^|[^a-z"\[])(`)([^`]+)(`)(?=[^a-z\t."'']|$)'
      captures:
        1: punctuation.definition.link.command.begin.vimhelp
        2: markup.underline.link.command.vimhelp
        3: punctuation.definition.link.command.end.vimhelp
    - match: '(?<=\s*)(.*?)(?=\s?)(~)$'
      captures:
        1: markup.heading.header.vimhelp
        2: punctuation.definition.keyword.vimhelp
    - match: '(.*) (?=`$)'
      captures:
        1: variable.other.graphic.vimhelp
        2: punctuation.definition.keyword.vimhelp
    - match: '\b(note:?|Note:?|NOTE:?|Notes:?)\b'
      scope: constant.other.note.vimhelp
    - match: '\b(WARNING:?|Warning:)\b'
      scope: constant.other.warning.vimhelp
    - match: '\b(DEPRECATED:?|Deprecated:)\b'
      scope: constant.other.deprecated.vimhelp
    - match: '(\{)([-_a-zA-Z0-9''"*+/:%#=\[\]<>.,]+)(\})'
      captures:
        1: punctuation.definition.constant.begin.vimhelp
        2: constant.numeric.vimhelp
        3: punctuation.definition.constant.end.vimhelp
    - match: '\[(range|line|count|offset|\+?cmd|(\+|-|)num|\+\+opt)\]'
      scope: constant.numeric.vimhelp
    - match: '\[(arg(uments)?|ident|addr|group)\]'
      scope: constant.numeric.vimhelp
    - match: '\[(readonly|fifo|socket|converted|crypted)\]'
      scope: constant.numeric.vimhelp
    - match: '<[-a-zA-Z0-9_]+>'
      scope: markup.underline.link.key.vimhelp
    - match: '<[SCM]-.>'
      scope: markup.underline.link.key.vimhelp
    - match: 'CTRL-((SHIFT-)?.|Break|PageUp|PageDown|Insert|Del|\{char\})'
      scope: markup.underline.link.key.vimhelp
    - match: '(META|ALT)-.'
      scope: markup.underline.link.key.vimhelp
    - match: '\b(((https?|ftp|gopher)://|(mailto|file|news):)[^'' 	<>"]+|(www|web|w3)[a-z0-9_-]*\.[a-z0-9._-]+\.[^'' 	<>"]+)[a-zA-Z0-9/]'
      scope: markup.underline.link.url.vimhelp
@@ -1,91 +0,0 @@
 %YAML 1.2
 ---
 # http://www.sublimetext.com/docs/3/syntax.html
 name: VimL
 file_extensions:
  - vim
  - .vimrc
 scope: source.viml
 contexts:
  main:
    - include: comment
    - include: string_quoted_double
    - include: string_quoted_single
    - include: string_regex
    - include: inline_comment
    - include: number_int
    - include: number_hex
    - include: keyword
    - include: support_function
    - include: support_variable
    - include: support_type
    - include: function_params
    - include: function_definition
    - include: function_call
    - include: function
    - include: variable
    - include: expr
  comment:
    - match: ^\s*".*$
      scope: comment.line.quotes.viml
      captures:
        1: punctuation.definition.comment.vim
  expr:
    - match: (\|\||&&|==(\?|#)?|(!|>|<)=(#|\?)?|(=|!)~(#|\?)?|(>|<)(#|\?)is|isnot|\.|\*|\\|%)
      scope: storage.function.viml
  function:
    - match: \b(fu(n|nction)?|end(f|fu|fun|function)?)\b
      scope: storage.function.viml
  function_call:
    - match: '(([sgbwtl]|)?:?[0-9a-zA-Z_#]+)(?=\()'
      scope: support.function.any-method
  function_definition:
    - match: '^\s*(function)\s*!?\s+(?=(s:)?[0-9a-zA-Z_#]+\s*\()'
      captures:
        1: storage.function.viml
      push:
        - meta_scope: meta.function.viml
        - match: (\()
          captures:
            1: punctuation.definition.parameters.begin.viml
          pop: true
        - match: "(s:)?[0-9a-zA-Z_#]+"
          scope: entity.name.function.viml
  function_params:
    - match: '-\w+='
      scope: support.type.viml
  inline_comment:
    - match: '(?!\$)(")(?!\{).*$\n?'
      scope: comment.line.quotes.viml
      captures:
        1: punctuation.definition.comment.vim
  keyword:
    - match: \b(if|while|for|try|return|throw|end(if|for|while|try)?|au(g|group)|else(if|)?|do|in|catch|finally|:)\b
      scope: keyword.control.viml
  number_hex:
    - match: "0x[0-9a-f]+"
      scope: constant.numeric.hex
  number_int:
    - match: '-?\d+'
      scope: constant.numeric.integer
  string_quoted_double:
    - match: '"(\\\\|\\"|\n[^\S\n]*\\|[^\n"])*"'
      scope: string.quoted.double.viml
  string_quoted_single:
    - match: '''(''''|\n[^\S\n]*\\|[^\n''])*'''
      scope: string.quoted.single.viml
  string_regex:
    - match: '/(\\\\|\\/|\n[^\S\n]*\\|[^\n/])*/'
      scope: string.regexp.viml
  support_function:
    - match: \b(set(local|global)?|let|command|filetype|colorscheme|\w*map|\w*a(b|brev)?|syn|exe(c|cute)?|ec(ho|)?|au(tocmd|)?)\b
      scope: support.function.viml
  support_type:
    - match: <.*?>
      scope: support.type.viml
  support_variable:
    - match: '\b(am(enu|)?|(hl|inc)?search|[Bb]uf([Nn]ew[Ff]ile|[Rr]ead)?|[Ff]ile[Tt]ype)\b'
      scope: support.variable.viml
  variable:
    - match: '([sSgGbBwWlLaAvV]:|@|$|&(?!&))\w*'
      scope: variable.other.viml
@@ -0,0 +1,182 @@
 %YAML 1.2
 ---
 # http://www.sublimetext.com/docs/3/syntax.html
 name: gnuplot
 file_extensions:
  - gp
  - gpl
  - gnuplot
  - gnu
  - plot
  - plt
 scope: source.gnuplot
 contexts:
  main:
    - include: number
    - include: string_single
    - include: string_double
    - match: '\b(for)\b\s*(\[)'
      comment: |
        gnuplot iteration statement.
                    There are two forms:
                        numeric [n = 1:2{:inc}]
                        string based [str in "x y z"]
                        but both can also iterate over lists etc, so this is kept loose.
      captures:
        1: keyword.other.iteration.gnuplot
        2: punctuation.definition.range.begin.gnuplot
      push:
        - meta_scope: meta.structure.iteration.gnuplot
        - match: '\]'
          captures:
            0: punctuation.definition.range.end.gnuplot
          pop: true
        - include: number
        - include: operator
        - include: string_double
        - include: string_single
        - match: ":"
          scope: punctuation.separator.range.gnuplot
        - match: '\b([a-zA-Z]\w*)\b\s*(=|in)'
          scope: variable-assignment.range.gnuplot
        - match: '(?i:[^\s(pi|e)\]])'
          scope: invalid.illegal.expected-range-separator.gnuplot
    - match: '\['
      comment: "gnuplot range statement [a:b]. Lots of things are legal, still more make no sense!"
      captures:
        0: punctuation.definition.range.begin.gnuplot
      push:
        - meta_scope: meta.structure.range.gnuplot
        - match: '\]'
          captures:
            0: punctuation.definition.range.end.gnuplot
          pop: true
        - include: number
        - include: operator
        - match: ":"
          scope: punctuation.separator.range.gnuplot
        - match: '(?i:[^\s(pi|e)\]])'
          scope: invalid.illegal.expected-range-separator.gnuplot
    - match: \\.
      scope: constant.character.escape.gnuplot
    - match: '(?<!\$)(#)(?!\{).*$\n?'
      scope: comment.line.number-sign.gnuplot
      captures:
        1: punctuation.definition.comment.gnuplot
    - match: for
      comment: introduce in gnuplot 4.3.
      scope: keyword.other.iteration.gnuplot
    - match: \b(angles|arrow|autoscale|bars|border|boxwidth|clabel|clip|cntrparam|colorbox|contour|decimalsign|dgrid3d|dummy|encoding|fit|format|grid|hidden3d|historysize|isosamples|key|label|locale|logscale|macros|bmargin|lmargin|rmargin|tmargin|mapping|mouse|multiplot|offsets|origin|output|palette|parametric|pm3d|pointsize|polar|print|rrange|trange|urange|vrange|samples|size|style|surface|tics|ticscale|ticslevel|timestamp|timefmt|title|view|xyplane|x2data|xdata|y2data|ydata|z2data|zdata|x2label|xlabel|y2label|ylabel|z2label|zlabel|x2range|xrange|y2range|yrange|z2range|zrange|mx2tics|mxtics|my2tics|mytics|mz2tics|mztics|nomx2tics|nomxtics|nomy2tics|nomytics|nomz2tics|nomztics|nox2tics|noxtics|noy2tics|noytics|noz2tics|noztics|x2tics|xtics|y2tics|ytics|z2tics|ztics|x2dtics|x2mtics|xdtics|xmtics|y2dtics|y2mtics|ydtics|ymtics|z2dtics|z2mtics|zdtics|zmtics|x2zeroaxis|xzeroaxis|y2zeroaxis|yzeroaxis|z2zeroaxis|zeroaxis|zzeroaxis|zero|)\b
      scope: keyword.other.setting.gnuplot
    - match: \b(cd|call|clear|exit|plot|splot|help|load|pause|quit|fit|replot|if|FIT_LIMIT|FIT_MAXITER|FIT_START_LAMBDA|FIT_LAMBDA_FACTOR|FIT_LOG|FIT_SCRIPT|print|pwd|reread|reset|save|show|test|!|functions|var)\b
      comment: missuse of scopes alert! Just for pretty colours
      scope: keyword.other.command.gnuplot
    - match: \b(abs|acos|acosh|arg|asin|asinh|atan|atan2|atanh|besj0|besj1|besy0|besy1|ceil|cos|cosh|erf|erfc|exp|floor|gamma|ibeta|igamma|imag|int|inverf|invnorm|lambertw|lgamma|log|log10|norm|rand|real|sgn|sin|sinh|sqrt|tan|tanh)\b
      scope: support.function.gnuplot
    - match: \b(gprintf|sprintf|strlen|strstrt|substr|system|word|words)\b
      scope: support.function.string.gnuplot
    - match: \b(on|off|default|inside|outside|lmargin|rmargin|tmargin|bmargin|at|left|right|center|top|bottom|center|vertical|horizontal|Left|Right|noreverse|noinvert|samplen|spacing|width|height|noautotitle|columnheader|title|noenhanced|nobox|linestyle|ls|linetype|lt|linewidth|lw)\b
      scope: constant.other.type.gnuplot
    - match: \b(aed512|aed767|aifm|aqua|bitgraph|cgm|corel|dumb|dxf|eepic|emf|emtex|epslatex|epson_180dpi|epson_60dpi|epson_lx800|fig|gif|gpic|hp2623A|hp2648|hp500c|hpdj|hpgl|hpljii|hppj|imagen|jpeg|kc_tek40xx|km_tek40xx|latex|mf|mif|mp|nec_cp6|okidata|pbm|pcl5|pdf|png|postscript|pslatex|pstex|pstricks|qms|regis|selanar|starc|svg|tandy_60dpi|tek40xx|tek410x|texdraw|tgif|tkcanvas|tpic|unknown|vttek)\b
      scope: constant.other.terminal.gnuplot
    - match: \b(u(sing)?|t(it(le)?)?|notit(le)?|w(i(th)?)?|steps|fs(teps)?|notitle|l(i(nes)?)?|linespoints|via)\b
      scope: keyword.modifier.gnuplot
    - match: |-
        (?x:
          \b # Start with a word boundary
          (?=\b[\w$]*(\(|.*=))  # Look-ahead for a bracket or equals
          (?![^(]*\)) # negative look ahead for a closing bracket without an opening one. This stops a from matching in f(a)
          (         # Group variable name
            [A-Za-z]      # A letter
            [\w$]*      # Any word chars or $
          )         # That is it for the name.
        )
      comment: user defined function / variable
      scope: variable.other.gnuplot
    - match: \b(if)\b
      scope: keyword.control.gnuplot
    - match: \b(show)\b
      captures:
        0: keyword.other.command.gnuplot
      push:
        - meta_scope: keyword.line.show.gnuplot
        - meta_content_scope: keyword.line.show.gnuplot
        - match: (?!\#)($\n?)
          pop: true
        - include: main
    - match: \b(set)\b\s*\b(terminal|term)\b
      captures:
        1: keyword.other.command.gnuplot
        2: keyword.other.setting.gnuplot
      push:
        - meta_scope: keyword.line.set.terminal.gnuplot
        - match: (?!\#)($\n?)
          pop: true
        - include: main
    - match: \b(set)\b\s*\b(key)\b
      captures:
        1: keyword.other.command.gnuplot
        2: keyword.other.setting.gnuplot
      push:
        - meta_scope: keyword.line.set.key.gnuplot
        - match: (?!\#)($\n?)
          pop: true
        - include: main
    - match: \b(set|unset)\b\s*(?!\b(terminal|key|for)\b)
      captures:
        1: keyword.other.command.gnuplot
        2: keyword.other.setting.gnuplot
      push:
        - meta_scope: keyword.line.set.gnuplot
        - meta_content_scope: keyword.line.set.gnuplot
        - match: (?!\#)($\n?)
          pop: true
        - include: main
  number:
    - match: |-
        (?x:         # turn on extended mode
            -?         # an optional minus
            (?:
              0        # a zero
              |        # ...or...
              [1-9]    # a 1-9 character
              \d*      # followed by zero or more digits
            )
            (?:
              \.       # a period
              \d+      # followed by one or more digits
              (?:
                [eE]   # an e character
                [+-]?  # followed by an option +/-
                \d+    # followed by one or more digits
              )?       # make exponent optional
            )?         # make decimal portion optional
        )
      comment: borrowed from textmate book
      scope: constant.numeric.gnuplot
  operator:
    - match: \s*(==|~=|>|>=|<|<=|&|&&|:|\||\|\||\+|-|\*|\.\*|/|\./|\\|\.\\|\^|\.\^)\s*
      comment: Operator symbols
      scope: keyword.operator.symbols.matlab
  string_double:
    - match: '"'
      captures:
        0: punctuation.definition.string.begin.gnuplot
      push:
        - meta_scope: string.quoted.double.gnuplot
        - match: '"'
          captures:
            0: punctuation.definition.string.end.gnuplot
          pop: true
        - match: '\\[\$`"\\\n]'
          scope: constant.character.escape.gnuplot
  string_single:
    - match: "'"
      captures:
        0: punctuation.definition.string.begin.gnuplot
      push:
        - meta_scope: string.quoted.single.gnuplot
        - match: "'"
          captures:
            0: punctuation.definition.string.end.gnuplot
          pop: true
@@ -0,0 +1,184 @@
 %YAML 1.2
 ---
 # See http://www.sublimetext.com/docs/3/syntax.html
 file_extensions:
  - log
 scope: text.log
 variables:
  ipv4_part: (?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)
  hours_minutes_seconds: (?:[01]\d|2[0-3]):(?:[0-5]\d):(?:[0-5]\d)
  error: \b(?i:fail(?:ure|ed)?|error|exception|fatal|critical)\b
  warning: \b(?i:warn(?:ing)?)\b
  info: \b(?i:info)\b
  debug: \b(?i:debug)\b
 contexts:
  main:
    - include: log_level_lines
    - include: main_without_log_level_line
  main_without_log_level_line:
    - match: (\w+)(=)
      captures:
        1: variable.parameter.log
        2: keyword.operator.assignment.log
    - match: (')([^']*)(')
      scope: string.quoted.single.log
      captures:
        1: punctuation.definition.string.begin.log
        3: punctuation.definition.string.end.log
    - match: \"
      captures:
        1: punctuation.definition.string.begin.log
      push: double_quoted_string
    - include: dates
    - include: ip_addresses
    - include: numbers
    - include: log_levels
    #- include: scope:text.html.markdown#autolink-inet
    - match: \b\w+:/{2,3}
      scope: markup.underline.link.scheme.log
      push: url-host
  log_level_lines:
    - match: ^(?=.*{{error}})
      push:
        - error_line
        - main_pop_at_eol
    - match: ^(?=.*{{warning}})
      push:
        - warning_line
        - main_pop_at_eol
    - match: ^(?=.*{{info}})
      push:
        - info_line
        - main_pop_at_eol
    - match: ^(?=.*{{debug}})
      push:
        - debug_line
        - main_pop_at_eol
  log_levels:
    - match: '{{error}}'
      scope: markup.error.log
    - match: '{{warning}}'
      scope: markup.warning.log
    - match: '{{info}}'
      scope: markup.info.log
    - match: '{{debug}}'
      scope: markup.info.log
  error_line:
    - meta_scope: meta.annotation.error-line.log
    - include: immediately_pop
  warning_line:
    - meta_scope: meta.annotation.warning-line.log
    - include: immediately_pop
  info_line:
    - meta_scope: meta.annotation.info-line.log
    - include: immediately_pop
  debug_line:
    - meta_scope: meta.annotation.debug-line.log
    - include: immediately_pop
  immediately_pop:
    - match: ''
      pop: true
  pop_at_eol:
    - match: $
      pop: true
  main_pop_at_eol:
    - include: main_without_log_level_line
    - include: pop_at_eol
  dates:
    - match: \b\d{4}-\d{2}-\d{2}(?=\b|T)
      scope: meta.date.log meta.number.integer.decimal.log constant.numeric.value.log
      push: maybe_date_time_separator
    - match: \b\d{4}/\d{2}/\d{2}(?=\b|T)
      scope: meta.date.log meta.number.integer.decimal.log constant.numeric.value.log
      push: maybe_date_time_separator
    - match: \b(?={{hours_minutes_seconds}})
      push: time
  time:
    - match: (?:{{hours_minutes_seconds}})(?:(\.)\d{3})?\b
      scope: meta.time.log meta.number.integer.decimal.log constant.numeric.value.log
      captures:
        1: punctuation.separator.decimal.log
    - include: immediately_pop
  maybe_date_time_separator:
    - match: T(?={{hours_minutes_seconds}})
      scope: meta.date.log meta.time.log keyword.other.log
      set: time
    - include: immediately_pop
  ip_addresses:
    - match: \b(?=(?:{{ipv4_part}}\.){3}{{ipv4_part}}\b)
      push:
        - meta_scope: meta.ipaddress.v4.log meta.number.integer.decimal.log
        - match: \d+
          scope: constant.numeric.value.log
        - match: \.
          scope: punctuation.separator.sequence.log
        - include: immediately_pop
    - match: (?=(?:\h{0,4}:){2,6}\h{1,4}\b)
      push:
        - meta_scope: meta.ipaddress.v6.log meta.number.integer.hexadecimal.log
        - match: \h{1,4}
          scope: constant.numeric.value.log
        - match: ':'
          scope: punctuation.separator.sequence.log
        - include: immediately_pop
  numbers:
    - match: \b(0x)(\h+)(?:(\.)(\h+))?\b
      scope: meta.number.float.hexadecimal.log
      captures:
        1: constant.numeric.base.log
        2: constant.numeric.value.log
        3: constant.numeric.value.log punctuation.separator.decimal.log
        4: constant.numeric.value.log
    - match: \b\d+(\.)\d+\b
      scope: meta.number.float.log constant.numeric.value.log
      captures:
        1: punctuation.separator.decimal.log
    - match: \b\d+\b
      scope: meta.number.integer.log constant.numeric.value.log
  url-host:
    - meta_content_scope: markup.underline.link.host.log
    - match: \[
      scope: punctuation.section.brackets.begin.log
      push:
        - match: \]
          scope: punctuation.section.brackets.end.log
          pop: true
        - include: ip_addresses
    - match: '[^:/\s]+'
    - match: ''
      set: url-after-host
  url-after-host:
    - match: (:)(\d+)
      scope: markup.underline.link.port.log
      captures:
        1: punctuation.separator.mapping.port.log
        2: constant.numeric.value.log
    #- include: scope:text.html.markdown#url-escaped-chars
    - match: (%)\h{2}
      scope: markup.underline.link.path.log constant.character.escape.url.log
      captures:
        1: punctuation.definition.escape.log
    # After a valid domain, zero or more non-space non-< characters may follow
    - match: (?=[?!.,:*_~]*[\s<]) # Trailing punctuation (specifically, ?, !, ., ,, :, *, _, and ~) will not be considered part of the autolink, though they may be included in the interior of the link
      pop: true
    - match: \( # When an autolink ends in ), we scan the entire autolink for the total number of parentheses. If there is a greater number of closing parentheses than opening ones, we don’t consider the last character part of the autolink, in order to facilitate including an autolink inside a parenthesis
      push:
        - meta_scope: markup.underline.link.path.log
        - match: (?=[?!.,:*_~]*[\s<])
          pop: true
        - match: \)
          pop: true
    - match: (?=\)[?!.,:*_~]*[\s<])
      pop: true
    - match: '[^?!.,:*_~\s<&()%]+|\S'
      scope: markup.underline.link.path.log
    - include: immediately_pop
  double_quoted_string:
    - meta_scope: string.quoted.double.log
    - match: \\"
      scope: constant.character.escape.log
    - match: \\n
      scope: constant.character.escape.log
    - match: \"
      scope: punctuation.definition.string.end.log
      pop: true
@@ -1,19 +0,0 @@
 %YAML 1.2
 ---
 # http://www.sublimetext.com/docs/3/syntax.html
 name: requirements.txt
 file_extensions:
  - requirements.txt
 scope: source.requirementstxt
 contexts:
  main:
    - match: (#).*$\n?
      scope: comment.line.requirementstxt
      captures:
        1: punctuation.definition.comment.requirementstxt
    - match: '(?i)^[a-z0-9_\-\.]+'
      scope: string.package_name.requirementstxt
    - match: (?i)==|<|<=|>=|>
      scope: keyword.operator.logical.punctuation.requirementstxt
    - match: '(?i)\d+\.[\da-z\-_\.]*'
      scope: constant.numeric.verions.requirementstxt
@@ -0,0 +1,60 @@
 # SYNTAX TEST "CSV.sublime-syntax"
 Forename,Surname,House No.,Street,City,Postcode
 #^^^^^^^ meta.field-1
 #       ^ punctuation.separator.sequence
 #        ^^^^^^^ meta.field-2
 #               ^ punctuation.separator.sequence
 #                ^^^^^^^^^ meta.field-3
 #                         ^ punctuation.separator.sequence
 #                          ^^^^^^ meta.field-4
 #                                ^ punctuation.separator.sequence
 #                                 ^^^^ meta.field-1
 #                                     ^ punctuation.separator.sequence
 #                                      ^^^^^^^^ meta.field-2
 John,Doe,87,Logon Road,Citiville,TU43 6GH
 #^^^ meta.field-1
 #   ^ punctuation.separator.sequence
 #    ^^^ meta.field-2
 #       ^ punctuation.separator.sequence
 #        ^^ meta.field-3
 #          ^ punctuation.separator.sequence
 #           ^^^^^^^^^^ meta.field-4
 #                     ^ punctuation.separator.sequence
 #                      ^^^^^^^^^ meta.field-1
 #                               ^ punctuation.separator.sequence
 #                                ^^^^^^^^ meta.field-2
 Jane,Doe,22,"""Fun"" Street","The City, County",FA90 1XA
 #^^^ meta.field-1
 #   ^ punctuation.separator.sequence
 #    ^^^ meta.field-2
 #       ^ punctuation.separator.sequence
 #        ^^ meta.field-3
 #          ^ punctuation.separator.sequence
 #           ^^^^^^^^^^^^^^^^ meta.field-4 string.quoted.double
 #            ^^ constant.character.escape
 #                 ^^ constant.character.escape
 #                           ^ punctuation.separator.sequence
 #                            ^ meta.field-1 string.quoted.double punctuation.definition.string.begin
 #                             ^^^^^^^^^^^^^^^^^ meta.field-1 string.quoted.double
 #                                             ^ meta.field-1 string.quoted.double punctuation.definition.string.end
 #                                              ^ punctuation.separator.sequence
 #                                               ^^^^^^^^ meta.field-2
 Fred,Bloggs,"19","Street
 #^^^ meta.field-1
 #   ^ punctuation.separator.sequence
 #    ^^^^^^ meta.field-2
 #          ^ punctuation.separator.sequence
 #            ^^^ meta.field-3 string.quoted.double
 #               ^ punctuation.separator.sequence
 #                ^ meta.field-4 punctuation.definition.string.begin
 #                ^^^^^^^^ meta.field-4 string.quoted.double
 Spanning Multiple ""
 #^^^^^^^^^^^^^^^^^^^^ meta.field-4 string.quoted.double
 #                 ^^ constant.character.escape
 Lines",Citee,P0stc0d3
 #^^^^^ meta.field-4 string.quoted.double
 #    ^ meta.field-4 punctuation.definition.string.end
 #     ^ punctuation.separator.sequence
 #      ^^^^^ meta.field-1
 #           ^ punctuation.separator.sequence
 #            ^^^^^^^^ meta.field-2
@@ -0,0 +1,419 @@
 # SYNTAX TEST "VimHelp.sublime-syntax"
 *helphelp.txt*	Nvim
 # <- punctuation.definition.constant.begin
 #^^^^^^^^^^^^ entity.name.reference.link
 #            ^ punctuation.definition.constant.end
 		  VIM REFERENCE MANUAL    by Bram Moolenaar
 #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ variable.language
 Help on help files					*helphelp*
                                      Type |gO| to see the table of contents.
 #                                          ^ punctuation.definition.link.begin
 #                                           ^^ markup.underline.link
 #                                             ^ punctuation.definition.link.end
 ==============================================================================
 #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ punctuation.definition.heading.1.setext
 1. Help commands					*online-help*
 #^^^^^^^^^^^^^^^ markup.heading.1.setext
 			*help* *<Help>* *:h* *:help* *<F1>* *i_<F1>* *i_<Help>*
 <Help>		or
 #^^^^^ markup.underline.link.key
 :h[elp]			Open a window and display the help file in read-only
 			mode.  If there is a help window open already, use
 			that one.  Otherwise, if the current window uses the
 			full width of the screen or is at least 80 characters
 			wide, the help window will appear just above the
 			current window.  Otherwise the new window is put at
 			the very top.
 			The 'helplang' option is used to select a language, if
 #      ^ punctuation.definition.link.option.begin
 #       ^^^^^^^^ markup.underline.link.option
 #               ^ punctuation.definition.link.option.end
 			the main help file is available in several languages.
 			Type |gO| to see the table of contents.
 						*{subject}* *E149* *E661*
 :h[elp] {subject}	Like ":help", additionally jump to the tag {subject}.
 			For example:  >
 				:help options
 <			{subject} can include wildcards such as "*", "?" and
 #   ^ punctuation.definition.constant.begin
 #    ^^^^^^^ constant.numeric
 #           ^ punctuation.definition.constant.end
 			"[a-z]":
 			   :help z?	jump to help for any "z" command
 			   :help z.	jump to the help for "z."
 			But when a tag exists it is taken literally:
 			   :help :?	jump to help for ":?"
 			If there is no full match for the pattern, or there
 			are several matches, the "best" match will be used.
 			A sophisticated algorithm is used to decide which
 			match is better than another one.  These items are
 			considered in the computation:
 			- A match with same case is much better than a match
 			  with different case.
 			- A match that starts after a non-alphanumeric
 			  character is better than a match in the middle of a
 			  word.
 			- A match at or near the beginning of the tag is
 			  better than a match further on.
 			- The more alphanumeric characters match, the better.
 			- The shorter the length of the match, the better.
 			The 'helplang' option is used to select a language, if
 			the {subject} is available in several languages.
 			To find a tag in a specific language, append "@ab",
 			where "ab" is the two-letter language code.  See
 			|help-translated|.
 			Note that the longer the {subject} you give, the less
 			matches will be found.  You can get an idea how this
 			all works by using commandline completion (type CTRL-D
 #                                                  ^^^^^^ markup.underline.link.key
 			after ":help subject" |c_CTRL-D|).
 			If there are several matches, you can have them listed
 			by hitting CTRL-D.  Example: >
 				:help cont<Ctrl-D>
 <			Instead of typing ":help CTRL-V" to search for help
 			for CTRL-V you can type: >
 				:help ^V
 <			This also works together with other characters, for
 			example to find help for CTRL-V in Insert mode: >
 				:help i^V
 <
 			It is also possible to first do ":help" and then
 			use ":tag {pattern}" in the help window.  The
 			":tnext" command can then be used to jump to other
 			matches, "tselect" to list matches and choose one. >
 				:help index
 				:tselect /.*mode
 <			When there is no argument you will see matches for
 			"help", to avoid listing all possible matches (that
 			would be very slow).
 			The number of matches displayed is limited to 300.
 			The `:help` command can be followed by '|' and another
 			command, but you don't need to escape the '|' inside a
 			help command.  So these both work: >
 				:help |
 				:help k| only
 <			Note that a space before the '|' is seen as part of
 #   ^^^^ constant.other.note
 			the ":help" argument.
 			You can also use <NL> or <CR> to separate the help
 			command from a following command.  You need to type
 			CTRL-V first to insert the <NL> or <CR>.  Example: >
 				:help so<C-V><CR>only
 <
 :h[elp]! [subject]	Like ":help", but in non-English help files prefer to
 			find a tag in a file with the same language as the
 			current file.  See |help-translated|.
 							*:helpc* *:helpclose*
 :helpc[lose]		Close one help window, if there is one.
 			Vim will try to restore the window layout (including
 			cursor position) to the same layout it was before
 			opening the help window initially.  This might cause
 			triggering several autocommands.
 							*:helpg* *:helpgrep*
 :helpg[rep] {pattern}[@xx]
 			Search all help text files and make a list of lines
 			in which {pattern} matches.  Jumps to the first match.
 			The optional [@xx] specifies that only matches in the
 			"xx" language are to be found.
 			You can navigate through the matches with the
 			|quickfix| commands, e.g., |:cnext| to jump to the
 			next one.  Or use |:cwindow| to get the list of
 			matches in the quickfix window.
 			{pattern} is used as a Vim regexp |pattern|.
 			'ignorecase' is not used, add "\c" to ignore case.
 			Example for case sensitive search: >
 				:helpgrep Uganda
 <			Example for case ignoring search: >
 				:helpgrep uganda\c
 <			Example for searching in French help: >
 				:helpgrep backspace@fr
 <			The pattern does not support line breaks, it must
 			match within one line.  You can use |:grep| instead,
 			but then you need to get the list of help files in a
 			complicated way.
 			Cannot be followed by another command, everything is
 			used as part of the pattern.  But you can use
 			|:execute| when needed.
 			Compressed help files will not be searched (Fedora
 			compresses the help files).
 							*:lh* *:lhelpgrep*
 :lh[elpgrep] {pattern}[@xx]
 			Same as ":helpgrep", except the location list is used
 			instead of the quickfix list.  If the help window is
 			already opened, then the location list for that window
 			is used.  Otherwise, a new help window is opened and
 			the location list for that window is set.  The
 			location list for the current window is not changed
 			then.
 							*:exu* *:exusage*
 :exu[sage]		Show help on Ex commands.  Added to simulate the Nvi
 			command.
 							*:viu* *:viusage*
 :viu[sage]		Show help on Normal mode commands.  Added to simulate
 			the Nvi command.
 When no argument is given to |:help| the file given with the 'helpfile' option
 will be opened.  Otherwise the specified tag is searched for in all "doc/tags"
 files in the directories specified in the 'runtimepath' option.
 If you would like to open the help in the current window, see this tip:
 |help-curwin|.
 The initial height of the help window can be set with the 'helpheight' option
 (default 20).
 						*help-buffer-options*
 When the help buffer is created, several local options are set to make sure
 the help text is displayed as it was intended:
    'iskeyword'		nearly all ASCII chars except ' ', '*', '"' and '|'
    'foldmethod'	"manual"
    'tabstop'		8
    'arabic'		off
    'binary'		off
    'buflisted'		off
    'cursorbind'	off
    'diff'		off
    'foldenable'	off
    'list'		off
    'modifiable'	off
    'number'		off
    'relativenumber'	off
    'rightleft'		off
    'scrollbind'	off
    'spell'		off
 Jump to specific subjects by using tags.  This can be done in two ways:
 - Use the "CTRL-]" command while standing on the name of a command or option.
  This only works when the tag is a keyword.  "<C-Leftmouse>" and
  "g<LeftMouse>" work just like "CTRL-]".
 - use the ":ta {subject}" command.  This also works with non-keyword
  characters.
 Use CTRL-T or CTRL-O to jump back.
 Use ":q" to close the help window.
 If there are several matches for an item you are looking for, this is how you
 can jump to each one of them:
 1. Open a help window
 2. Use the ":tag" command with a slash prepended to the tag.  E.g.: >
 	:tag /min
 3. Use ":tnext" to jump to the next matching tag.
 It is possible to add help files for plugins and other items.  You don't need
 to change the distributed help files for that.  See |add-local-help|.
 To write a local help file, see |write-local-help|.
 Note that the title lines from the local help files are automagically added to
 the "LOCAL ADDITIONS" section in the "help.txt" help file |local-additions|.
 This is done when viewing the file in Vim, the file itself is not changed.  It
 is done by going through all help files and obtaining the first line of each
 file.  The files in $VIMRUNTIME/doc are skipped.
 							*help-xterm-window*
 If you want to have the help in another xterm window, you could use this
 command: >
 	:!xterm -e vim +help &
 <
 					*:helpt* *:helptags*
 			*E150* *E151* *E152* *E153* *E154* *E670* *E856*
 :helpt[ags] [++t] {dir}
 			Generate the help tags file(s) for directory {dir}.
 			When {dir} is ALL then all "doc" directories in
 			'runtimepath' will be used.
 			All "*.txt" and "*.??x" files in the directory and
 			sub-directories are scanned for a help tag definition
 			in between stars.  The "*.??x" files are for
 			translated docs, they generate the "tags-??" file, see
 			|help-translated|.  The generated tags files are
 			sorted.
 			When there are duplicates an error message is given.
 			An existing tags file is silently overwritten.
 			The optional "++t" argument forces adding the
 			"help-tags" tag.  This is also done when the {dir} is
 			equal to $VIMRUNTIME/doc.
 			To rebuild the help tags in the runtime directory
 			(requires write permission there): >
 				:helptags $VIMRUNTIME/doc
 <
 ==============================================================================
 2. Translated help files				*help-translated*
 It is possible to add translated help files, next to the original English help
 files.  Vim will search for all help in "doc" directories in 'runtimepath'.
 At this moment translations are available for:
 	Chinese  - multiple authors
 	French   - translated by David Blanchet
 	Italian  - translated by Antonio Colombo
 	Japanese - multiple authors
 	Polish   - translated by Mikolaj Machowski
 	Russian  - translated by Vassily Ragosin
 See the Vim website to find them: http://www.vim.org/translations.php
 A set of translated help files consists of these files:
 	help.abx
 	howto.abx
 	...
 	tags-ab
 "ab" is the two-letter language code.  Thus for Italian the names are:
 	help.itx
 	howto.itx
 	...
 	tags-it
 The 'helplang' option can be set to the preferred language(s).  The default is
 set according to the environment.  Vim will first try to find a matching tag
 in the preferred language(s).  English is used when it cannot be found.
 To find a tag in a specific language, append "@ab" to a tag, where "ab" is the
 two-letter language code.  Example: >
 	:he user-manual@it
 	:he user-manual@en
 The first one finds the Italian user manual, even when 'helplang' is empty.
 The second one finds the English user manual, even when 'helplang' is set to
 "it".
 When using command-line completion for the ":help" command, the "@en"
 extension is only shown when a tag exists for multiple languages.  When the
 tag only exists for English "@en" is omitted.  When the first candidate has an
 "@ab" extension and it matches the first language in 'helplang' "@ab" is also
 omitted.
 When using |CTRL-]| or ":help!" in a non-English help file Vim will try to
 find the tag in the same language.  If not found then 'helplang' will be used
 to select a language.
 Help files must use latin1 or utf-8 encoding.  Vim assumes the encoding is
 utf-8 when finding non-ASCII characters in the first line.  Thus you must
 translate the header with "For Vim version".
 The same encoding must be used for the help files of one language in one
 directory.  You can use a different encoding for different languages and use
 a different encoding for help files of the same language but in a different
 directory.
 Hints for translators:
 - Do not translate the tags.  This makes it possible to use 'helplang' to
  specify the preferred language.  You may add new tags in your language.
 - When you do not translate a part of a file, add tags to the English version,
  using the "tag@en" notation.
 - Make a package with all the files and the tags file available for download.
  Users can drop it in one of the "doc" directories and start use it.
  Report this to Bram, so that he can add a link on www.vim.org.
 - Use the |:helptags| command to generate the tags files.  It will find all
  languages in the specified directory.
 ==============================================================================
 3. Writing help files					*help-writing*
 For ease of use, a Vim help file for a plugin should follow the format of the
 standard Vim help files, except for the first line.  If you are writing a new
 help file it's best to copy one of the existing files and use it as a
 template.
 The first line in a help file should have the following format:
 *plugin_name.txt*	{short description of the plugin}
 The first field is a help tag where ":help plugin_name" will jump to.  The
 remainder of the line, after a Tab, describes the plugin purpose in a short
 way.  This will show up in the "LOCAL ADDITIONS" section of the main help
 file.  Check there that it shows up properly: |local-additions|.
 If you want to add a version number or last modification date, put it in the
 second line, right aligned.
 At the bottom of the help file, place a Vim modeline to set the 'textwidth'
 and 'tabstop' options and the 'filetype' to "help".  Never set a global option
 in such a modeline, that can have undesired consequences.
 TAGS
 To define a help tag, place the name between asterisks (*tag-name*).  The
 tag-name should be different from all the Vim help tag names and ideally
 should begin with the name of the Vim plugin.  The tag name is usually right
 aligned on a line.
 When referring to an existing help tag and to create a hot-link, place the
 name between two bars (|) eg. |help-writing|.
 When referring to a Vim command and to create a hot-link, place the
 name between two backticks, eg. inside `:filetype`.  You will see this is
 highlighted as a command, like a code block (see below).
 When referring to a Vim option in the help file, place the option name between
 two single quotes, eg. 'statusline'
 When referring to any other technical term, such as a filename or function
 parameter, surround it in backticks, eg. `~/.path/to/init.vim`.
 HIGHLIGHTING
 To define a column heading, use a tilde character at the end of the line.
 This will highlight the column heading in a different color.  E.g.
 Column heading~
 #^^^^^^^^^^^^^ markup.heading.header
 #             ^ punctuation.definition.keyword
 To separate sections in a help file, place a series of '=' characters in a
 line starting from the first column.  The section separator line is highlighted
 differently.
 To quote a block of ex-commands verbatim, place a greater than (>) character
 at the end of the line before the block and a less than (<) character as the
 first non-blank on a line following the block.  Any line starting in column 1
 also implicitly stops the block of ex-commands before it.  E.g. >
    function Example_Func()
 	echo "Example"
    endfunction
 <
 The following are highlighted differently in a Vim help file:
  - a special key name expressed either in <> notation as in <PageDown>, or
    as a Ctrl character as in CTRL-X
  - anything between {braces}, e.g. {lhs} and {rhs}
 The word "Note", "Notes" and similar automagically receive distinctive
 highlighting.  So do these:
 	*Todo	something to do
 	*Error	something wrong
 You can find the details in $VIMRUNTIME/syntax/help.vim
 vim:tw=78:ts=8:noet:ft=help:norl:
 #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ comment.line.modeline
@@ -149,3 +149,116 @@ EXAMPLE
           #define POLLIN_SET  (EPOLLRDNORM | EPOLLRDBAND | EPOLLIN |
                                EPOLLHUP | EPOLLERR)
 #                                                  ^ source.c meta.preprocessor.macro meta.group punctuation.section.group.end
 ENVIRONMENT
       $SYSTEMD_LOG_LEVEL
 #      ^ punctuation.definition.variable
 #       ^^^^^^^^^^^^^^^^^ constant.other
           systemd reads the log level from this environment variable. This
           can be overridden with --log-level=.
 ENVIRONMENT VARIABLES
       Various Git commands use the following environment variables:
   The Git Repository
       These environment variables apply to all core Git commands. Nb: it is
       worth noting that they may be used/overridden by SCMS sitting above Git
       so take care if using a foreign front-end.
       GIT_INDEX_FILE
 #      ^^^^^^^^^^^^^^ support.constant.environment-variable
           This environment allows the specification of an alternate index
           file. If not specified, the default of $GIT_DIR/index is used.
       GIT_INDEX_VERSION
 #      ^^^^^^^^^^^^^^^^^ support.constant.environment-variable
           This environment variable allows the specification of an index
           version for new repositories. It won’t affect existing index files.
           By default index file version 2 or 3 is used. See git-update-
           index(1) for more information.
 COMMANDS
       This section only lists general commands. For input and output com‐
       mands, refer to sway-input(5) and sway-output(5).
       The following commands may only be used in the configuration file.
       bar [<bar-id>] <bar-subcommands...>
 #      ^^^ entity.name.command
 #          ^ punctuation.section.brackets.begin
 #           ^ punctuation.definition.generic.begin
 #            ^^^^^^ variable.parameter
 #                  ^ punctuation.definition.generic.end
 #                   ^ punctuation.section.brackets.end
 #                     ^ punctuation.definition.generic.begin
 #                      ^^^^^^^^^^^^^^^ variable.parameter
 #                                        ^ punctuation.definition.generic.end
           For details on bar subcommands, see sway-bar(5).
       default_orientation horizontal|vertical|auto
 #      ^^^^^^^^^^^^^^^^^^^ entity.name.command
 #                          ^^^^^^^^^^ variable.parameter
 #                                    ^ keyword.operator.logical
 #                                     ^^^^^^^^ variable.parameter
 #                                             ^ keyword.operator.logical
 #                                              ^^^^ variable.parameter
           Sets the default container layout for tiled containers.
       include <path>
           Includes another file from path. path can be either a full path or
           a path relative to the parent config, and expands shell syntax (see
           wordexp(3) for details). The same include file can only be included
           once; subsequent attempts will be ignored.
       The following commands cannot be used directly in the configuration
 #      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - variable - entity
       file. They are expected to be used with bindsym or at runtime through
 #      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - variable - entity
       swaymsg(1).
       border none|normal|csd|pixel [<n>]
           Set border style for focused window. normal includes a border of
           thickness n and a title bar. pixel is a border without title bar n
           pixels thick. Default is normal with border thickness 2. csd is
           short for client-side-decorations, which allows the client to draw
           its own decorations.
       border toggle
 #      ^^^^^^ entity.name.command
           Cycles through the available border styles.
       exit
 #      ^^^^ entity.name.command
           Exit sway and end your Wayland session.
       floating enable|disable|toggle
           Make focused view floating, non-floating, or the opposite of what
           it is now.
       <criteria> focus
 #      ^ punctuation.definition.generic.begin
 #       ^^^^^^^^ variable.parameter
 #               ^ punctuation.definition.generic.end
 #                 ^^^^^ variable.parameter
           Moves focus to the container that matches the specified criteria.
       gaps inner|outer|horizontal|vertical|top|right|bottom|left all|current
       set|plus|minus|toggle <amount>
 #      ^^^ variable.parameter
 #         ^ keyword.operator.logical
           Changes the inner or outer gaps for either all workspaces or the
           current workspace. outer gaps can be altered per side with top,
           right, bottom, and left or per direction with horizontal and verti‐
           cal.
       layout toggle [split|tabbed|stacking|splitv|splith]
       [split|tabbed|stacking|splitv|splith]...
 #      ^ punctuation.section.brackets.begin
 #       ^^^^^ variable.parameter
 #            ^ keyword.operator.logical
           Cycles the layout mode of the focused container through a list of
           layouts.
 SEE ALSO
       The systemd Homepage[11], systemd-system.conf(5), locale.conf(5)
 #                                ^^^^^^^^^^^^^^^^^^^ entity.name.function
--- a/Show More
+++ b/Show More
`@@ -1,2 +1 @@`
	`blank_issues_enabled: true`	`blank_issues_enabled: true`