build(deps): bump assets/syntaxes/02_Extra/Slim

Bumps [assets/syntaxes/02_Extra/Slim](https://github.com/slim-template/ruby-slim.tmbundle) from `3b1441f` to `cad0268`.
- [Commits](3b1441f89f...cad02689b6)

---
updated-dependencies:
- dependency-name: assets/syntaxes/02_Extra/Slim
  dependency-version: cad02689b6c6e03d67dab8eaadb22cf0fd3b436b
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>

.cargo/audit.toml

@@ -0,0 +1,2 @@
+[advisories]
+ignore = ["RUSTSEC-2024-0320", "RUSTSEC-2024-0421"]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -7,9 +7,26 @@ assignees: ''
 
 ---
 
-<!-- Hey there, thank you for creating an issue! -->
+<!--
 
-**Describe the bug you encountered:**
+Hey there, thank you for reporting a bug!
+
+Please note that the following bugs have already been reported:
+
+* dpkg: error processing archive /some/path/some-program.deb (--unpack):
+  trying to overwrite '/usr/.crates2.json'
+
+  See https://github.com/sharkdp/bat/issues/938
+
+-->
+
+**What steps will reproduce the bug?**
+
+1. step 1
+2. step 2
+3. ...
+
+**What happens?**
 
 ...
 

.github/ISSUE_TEMPLATE/question.md

@@ -7,3 +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. -->

.github/ISSUE_TEMPLATE/syntax_request.md

@@ -26,4 +26,4 @@ guidelines for adding new syntaxes:
 [Name or description of the syntax/language here]
 
 **Guideline Criteria:**
-[packagecontro.io link here]
+[packagecontrol.io link here]

.github/dependabot.yml

@@ -16,3 +16,9 @@ updates:
     interval: monthly
     time: "04:00"
     timezone: Europe/Berlin
+- package-ecosystem: "github-actions"
+  directory: "/"
+  schedule:
+    interval: monthly
+    time: "04:00"
+    timezone: Europe/Berlin

.github/workflows/CICD.yml

@@ -1,8 +1,8 @@
 name: CICD
 
 env:
-  MIN_SUPPORTED_RUST_VERSION: "1.45.0"
   CICD_INTERMEDIATES_DIR: "_cicd-intermediates"
+  MSRV_FEATURES: --no-default-features --features minimal-application,bugreport,build-assets
 
 on:
   workflow_dispatch:
@@ -14,108 +14,171 @@ on:
       - '*'
 
 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
+      - lint
+      - 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@v5
+    - 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 }}
+
+  lint:
+    name: Ensure code quality
+    runs-on: ubuntu-latest
+    steps:
+    - uses: dtolnay/rust-toolchain@stable
+      with:
+        components: rustfmt,clippy
+    - uses: actions/checkout@v5
+    - run: cargo fmt -- --check
+    - run: cargo clippy --locked --all-targets --all-features -- -D warnings
+
   min_version:
     name: Minimum supported rust version
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
+    needs: crate_metadata
     steps:
     - name: Checkout source code
-      uses: actions/checkout@v2
-
-    - name: Install rust toolchain (v${{ env.MIN_SUPPORTED_RUST_VERSION }})
-      uses: actions-rs/toolchain@v1
+      uses: actions/checkout@v5
+    - name: Install rust toolchain (v${{ needs.crate_metadata.outputs.msrv }})
+      uses: dtolnay/rust-toolchain@master
       with:
-        toolchain: ${{ env.MIN_SUPPORTED_RUST_VERSION }}
-        default: true
-        profile: minimal # minimal component installation (ie, no documentation)
-        components: clippy, rustfmt
-    - name: Ensure `cargo fmt` has been run
-      uses: actions-rs/cargo@v1
-      with:
-        command: fmt
-        args: -- --check
-    - name: Run clippy (on minimum supported rust version to prevent warnings we can't fix)
-      uses: actions-rs/cargo@v1
-      with:
-        command: clippy
-        args: --locked --all-targets --all-features
+        toolchain: ${{ needs.crate_metadata.outputs.msrv }}
     - name: Run tests
-      uses: actions-rs/cargo@v1
+      run: cargo test --locked ${{ env.MSRV_FEATURES }}
+
+  license_checks:
+    name: License checks
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v5
       with:
-        command: test
-        args: --locked
+        submodules: true # we especially want to perform license checks on submodules
+    - run: tests/scripts/license-checks.sh
 
   test_with_new_syntaxes_and_themes:
     name: Run tests with updated syntaxes and themes
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
     - name: Git checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v5
       with:
         submodules: true # we need all syntax and theme submodules
     - name: Install Rust toolchain
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        default: true
-        profile: minimal
+      uses: dtolnay/rust-toolchain@stable
     - name: Build and install bat
-      uses: actions-rs/cargo@v1
-      with:
-        command: install
-        args: --locked --path .
+      run: cargo install --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
-      with:
-        command: install
-        args: --locked --path .
+      run: cargo install --locked --path .
     - name: Run unit tests with new syntaxes and themes
-      uses: actions-rs/cargo@v1
-      with:
-        command: test
-        args: --locked --release
+      run: cargo test --locked --release
     - name: Run ignored-by-default unit tests with new syntaxes and themes
-      uses: actions-rs/cargo@v1
-      with:
-        command: test
-        args: --locked --release -- --ignored
+      run: cargo test --locked --release --test assets -- --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-latest
+    steps:
+    - name: Git checkout
+      uses: actions/checkout@v5
+    - 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-latest
+    steps:
+    - name: Git checkout
+      uses: actions/checkout@v5
+    - name: Install Rust toolchain
+      uses: dtolnay/rust-toolchain@stable
     - name: Check documentation
       env:
         RUSTDOCFLAGS: -D warnings
-      uses: actions-rs/cargo@v1
-      with:
-        command: doc
-        args: --locked --no-deps --document-private-items --all-features
+      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:
+      - run: cargo install cargo-audit --locked
+      - uses: actions/checkout@v5
+      - run: cargo audit
 
   build:
-    name: ${{ matrix.job.os }} (${{ matrix.job.target }})
+    name: ${{ matrix.job.target }} (${{ matrix.job.os }})
     runs-on: ${{ matrix.job.os }}
+    needs: crate_metadata
     strategy:
       fail-fast: false
       matrix:
         job:
-          - { os: ubuntu-20.04, target: arm-unknown-linux-gnueabihf , use-cross: true }
-          - { os: ubuntu-20.04, target: arm-unknown-linux-musleabihf, use-cross: true }
-          - { os: ubuntu-20.04, target: aarch64-unknown-linux-gnu   , use-cross: true }
-          - { os: ubuntu-20.04, target: i686-unknown-linux-gnu      , use-cross: true }
-          - { os: ubuntu-20.04, target: i686-unknown-linux-musl     , use-cross: true }
-          - { os: ubuntu-20.04, target: x86_64-unknown-linux-gnu    }
-          - { os: ubuntu-20.04, target: x86_64-unknown-linux-musl   , use-cross: true }
-          - { os: macos-10.15 , target: x86_64-apple-darwin         }
-          # - { os: windows-2019, target: i686-pc-windows-gnu         }  ## disabled; error: linker `i686-w64-mingw32-gcc` not found
-          - { os: windows-2019, target: i686-pc-windows-msvc        }
-          - { os: windows-2019, target: x86_64-pc-windows-gnu       }
-          - { os: windows-2019, target: x86_64-pc-windows-msvc      }
+          - { target: aarch64-unknown-linux-musl  , os: ubuntu-latest, dpkg_arch: arm64,            use-cross: true }
+          - { target: aarch64-unknown-linux-gnu   , os: ubuntu-latest, dpkg_arch: arm64,            use-cross: true }
+          - { target: arm-unknown-linux-gnueabihf , os: ubuntu-latest, dpkg_arch: armhf,            use-cross: true }
+          - { target: arm-unknown-linux-musleabihf, os: ubuntu-latest, dpkg_arch: musl-linux-armhf, use-cross: true }
+          - { target: i686-pc-windows-msvc        , os: windows-2025,                                              }
+          - { target: i686-unknown-linux-gnu      , os: ubuntu-latest, dpkg_arch: i686,             use-cross: true }
+          - { target: i686-unknown-linux-musl     , os: ubuntu-latest, dpkg_arch: musl-linux-i686,  use-cross: true }
+          - { target: x86_64-apple-darwin         , os: macos-13,                                                  }
+          - { target: aarch64-apple-darwin        , os: macos-14,                                                  }
+          - { target: x86_64-pc-windows-msvc      , os: windows-2025,                                              }
+          - { target: aarch64-pc-windows-msvc     , os: windows-11-arm,                                            }
+          - { target: x86_64-unknown-linux-gnu    , os: ubuntu-latest, dpkg_arch: amd64,            use-cross: true }
+          - { target: x86_64-unknown-linux-musl   , os: ubuntu-latest, dpkg_arch: musl-linux-amd64, use-cross: true }
+    env:
+      BUILD_CMD: cargo
     steps:
     - name: Checkout source code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v5
 
     - name: Install prerequisites
       shell: bash
@@ -125,21 +188,21 @@ jobs:
           aarch64-unknown-linux-gnu) sudo apt-get -y update ; sudo apt-get -y install gcc-aarch64-linux-gnu ;;
         esac
 
-    - name: Extract crate information
-      shell: bash
-      run: |
-        echo "PROJECT_NAME=$(sed -n 's/^name = "\(.*\)"/\1/p' Cargo.toml | head -n1)" >> $GITHUB_ENV
-        echo "PROJECT_VERSION=$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)" >> $GITHUB_ENV
-        echo "PROJECT_MAINTAINER=$(sed -n 's/^authors = \["\(.*\)"\]/\1/p' Cargo.toml)" >> $GITHUB_ENV
-        echo "PROJECT_HOMEPAGE=$(sed -n 's/^homepage = "\(.*\)"/\1/p' Cargo.toml)" >> $GITHUB_ENV
-
     - name: Install Rust toolchain
-      uses: actions-rs/toolchain@v1
+      uses: dtolnay/rust-toolchain@stable
       with:
-        toolchain: stable
-        target: ${{ matrix.job.target }}
-        override: true
-        profile: minimal # minimal component installation (ie, no documentation)
+        targets: ${{ matrix.job.target }}
+
+    - name: Install cross
+      if: matrix.job.use-cross
+      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
@@ -152,14 +215,11 @@ jobs:
         rustc -V
 
     - name: Build
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ matrix.job.use-cross }}
-        command: build
-        args: --locked --release --target=${{ matrix.job.target }}
+      shell: bash
+      run: $BUILD_CMD build --locked --release --target=${{ matrix.job.target }}
 
-    - name: Strip debug information from executable
-      id: strip
+    - name: Set binary name & path
+      id: bin
       shell: bash
       run: |
         # Figure out suffix of binary
@@ -168,31 +228,13 @@ jobs:
           *-pc-windows-*) EXE_suffix=".exe" ;;
         esac;
 
-        # Figure out what strip tool to use if any
-        STRIP="strip"
-        case ${{ matrix.job.target }} in
-          arm-unknown-linux-*) STRIP="arm-linux-gnueabihf-strip" ;;
-          aarch64-unknown-linux-gnu) STRIP="aarch64-linux-gnu-strip" ;;
-          *-pc-windows-msvc) STRIP="" ;;
-        esac;
-
         # Setup paths
-        BIN_DIR="${{ env.CICD_INTERMEDIATES_DIR }}/stripped-release-bin/"
-        mkdir -p "${BIN_DIR}"
-        BIN_NAME="${{ env.PROJECT_NAME }}${EXE_suffix}"
-        BIN_PATH="${BIN_DIR}/${BIN_NAME}"
+        BIN_NAME="${{ needs.crate_metadata.outputs.name }}${EXE_suffix}"
+        BIN_PATH="target/${{ matrix.job.target }}/release/${BIN_NAME}"
 
-        # Copy the release build binary to the result location
-        cp "target/${{ matrix.job.target }}/release/${BIN_NAME}" "${BIN_DIR}"
-
-        # Also strip if possible
-        if [ -n "${STRIP}" ]; then
-          "${STRIP}" "${BIN_PATH}"
-        fi
-
-        # Let subsequent steps know where to find the (stripped) bin
-        echo ::set-output name=BIN_PATH::${BIN_PATH}
-        echo ::set-output name=BIN_NAME::${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
@@ -200,73 +242,55 @@ jobs:
       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 ${PROJECT_NAME}" ;; esac;
-        echo ::set-output name=CARGO_TEST_OPTIONS::${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
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ matrix.job.use-cross }}
-        command: test
-        args: --locked --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}}
+      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
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ matrix.job.use-cross }}
-        command: run
-        args: --locked --target=${{ matrix.job.target }} -- --paging=never --color=always --theme=ansi Cargo.toml src/config.rs
+      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)
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ matrix.job.use-cross }}
-        command: run
-        args: --locked --target=${{ matrix.job.target }} -- --paging=never --color=always --theme=ansi Cargo.toml src/config.rs --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"
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ matrix.job.use-cross }}
-        command: check
-        args: --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features 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"
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ matrix.job.use-cross }}
-        command: check
-        args: --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features 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"
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ matrix.job.use-cross }}
-        command: check
-        args: --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features 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"
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ matrix.job.use-cross }}
-        command: check
-        args: --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features 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"
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ matrix.job.use-cross }}
-        command: check
-        args: --locked --target=${{ matrix.job.target }} --verbose --no-default-features --features 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=${PROJECT_NAME}-v${PROJECT_VERSION}-${{ matrix.job.target }}
+        PKG_BASENAME=${{ needs.crate_metadata.outputs.name }}-v${{ needs.crate_metadata.outputs.version }}-${{ matrix.job.target }}
         PKG_NAME=${PKG_BASENAME}${PKG_suffix}
-        echo ::set-output name=PKG_NAME::${PKG_NAME}
+        echo "PKG_NAME=${PKG_NAME}" >> $GITHUB_OUTPUT
 
         PKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/package"
         ARCHIVE_DIR="${PKG_STAGING}/${PKG_BASENAME}/"
@@ -274,18 +298,19 @@ jobs:
         mkdir -p "${ARCHIVE_DIR}/autocomplete"
 
         # Binary
-        cp "${{ steps.strip.outputs.BIN_PATH }}" "$ARCHIVE_DIR"
-
-        # Man page
-        cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/manual/bat.1 "$ARCHIVE_DIR"
+        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/${{ needs.crate_metadata.outputs.name }}'-*/out/assets/manual/bat.1 "$ARCHIVE_DIR"
+
         # Autocompletion files
-        cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.bash "$ARCHIVE_DIR/autocomplete/${{ env.PROJECT_NAME }}.bash"
-        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/${{ 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.bash "$ARCHIVE_DIR/autocomplete/${{ needs.crate_metadata.outputs.name }}.bash"
+        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 "${PKG_STAGING}/" >/dev/null
@@ -296,7 +321,7 @@ jobs:
         popd >/dev/null
 
         # Let subsequent steps know where to find the compressed package
-        echo ::set-output name=PKG_PATH::"${PKG_STAGING}/${PKG_NAME}"
+        echo "PKG_PATH=${PKG_STAGING}/${PKG_NAME}" >> $GITHUB_OUTPUT
 
     - name: Create Debian package
       id: debian-package
@@ -308,33 +333,25 @@ jobs:
         DPKG_DIR="${DPKG_STAGING}/dpkg"
         mkdir -p "${DPKG_DIR}"
 
-        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;
-        DPKG_VERSION=${PROJECT_VERSION}
-
-        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 ;;
-          *) DPKG_ARCH=notset ;;
-        esac;
-
+        DPKG_BASENAME=${{ needs.crate_metadata.outputs.name }}
+        DPKG_CONFLICTS=${{ needs.crate_metadata.outputs.name }}-musl
+        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 }}
+        DPKG_ARCH="${{ matrix.job.dpkg_arch }}"
         DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb"
-        echo ::set-output name=DPKG_NAME::${DPKG_NAME}
+        echo "DPKG_NAME=${DPKG_NAME}" >> $GITHUB_OUTPUT
 
         # Binary
-        install -Dm755 "${{ steps.strip.outputs.BIN_PATH }}" "${DPKG_DIR}/usr/bin/${{ steps.strip.outputs.BIN_NAME }}"
+        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/${{ env.PROJECT_NAME }}'-*/out/assets/manual/bat.1 "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
-        gzip -n --best "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"
+        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/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.fish "${DPKG_DIR}/usr/share/fish/vendor_completions.d/${{ env.PROJECT_NAME }}.fish"
-        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 }}"
+        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"
@@ -345,12 +362,12 @@ jobs:
 
         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 }}
-        Source: ${{ env.PROJECT_HOMEPAGE }}
+        Upstream-Name: ${{ needs.crate_metadata.outputs.name }}
+        Source: ${{ needs.crate_metadata.outputs.homepage }}
 
         Files: *
-        Copyright: ${{ env.PROJECT_MAINTAINER }}
-        Copyright: $COPYRIGHT_YEARS ${{ 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
@@ -391,17 +408,17 @@ jobs:
         Version: ${DPKG_VERSION}
         Section: utils
         Priority: optional
-        Maintainer: ${{ env.PROJECT_MAINTAINER }}
-        Homepage: ${{ env.PROJECT_HOMEPAGE }}
+        Maintainer: ${{ needs.crate_metadata.outputs.maintainer }}
+        Homepage: ${{ needs.crate_metadata.outputs.homepage }}
         Architecture: ${DPKG_ARCH}
-        Provides: ${{ env.PROJECT_NAME }}
+        Provides: ${{ needs.crate_metadata.outputs.name }}
         Conflicts: ${DPKG_CONFLICTS}
         Description: cat(1) clone with wings.
           A cat(1) clone with syntax highlighting and Git integration.
         EOF
 
         DPKG_PATH="${DPKG_STAGING}/${DPKG_NAME}"
-        echo ::set-output name=DPKG_PATH::${DPKG_PATH}
+        echo "DPKG_PATH=${DPKG_PATH}" >> $GITHUB_OUTPUT
 
         # build dpkg
         fakeroot dpkg-deb --build "${DPKG_DIR}" "${DPKG_PATH}"
@@ -424,10 +441,10 @@ jobs:
       shell: bash
       run: |
         unset IS_RELEASE ; if [[ $GITHUB_REF =~ ^refs/tags/v[0-9].* ]]; then IS_RELEASE='true' ; fi
-        echo ::set-output name=IS_RELEASE::${IS_RELEASE}
+        echo "IS_RELEASE=${IS_RELEASE}" >> $GITHUB_OUTPUT
 
     - name: Publish archives and packages
-      uses: softprops/action-gh-release@v1
+      uses: softprops/action-gh-release@v2
       if: steps.is-release.outputs.IS_RELEASE
       with:
         files: |
@@ -435,3 +452,15 @@ jobs:
           ${{ steps.debian-package.outputs.DPKG_PATH }}
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  winget:
+    name: Publish to Winget
+    runs-on: ubuntu-latest
+    needs: build
+    if: startsWith(github.ref, 'refs/tags/v')
+    steps:
+      - uses: vedantmgoyal9/winget-releaser@19e706d4c9121098010096f9c495a70a7518b30f
+        with:
+          identifier: sharkdp.bat
+          installers-regex: '-pc-windows-msvc\.zip$'
+          token: ${{ secrets.WINGET_TOKEN }}

.github/workflows/require-changelog-for-PRs.yml

@@ -0,0 +1,33 @@
+name: Changelog
+
+on:
+  pull_request:
+
+jobs:
+  check-changelog:
+    name: Check for changelog entry
+    runs-on: ubuntu-latest
+    # dependabot PRs are automerged if CI passes; we shouldn't block these
+    if: github.actor != 'dependabot[bot]'
+    env:
+      PR_NUMBER: ${{ github.event.number }}
+      PR_BASE: ${{ github.base_ref }}
+    steps:
+      - uses: actions/checkout@v5
+      - name: Fetch PR base
+        run: git fetch --no-tags --prune --depth=1 origin
+
+      # cannot use `github.actor`: the triggering commit may be authored by a maintainer
+      - name: Get PR submitter
+        id: get-submitter
+        run: curl -sSfL https://api.github.com/repos/sharkdp/bat/pulls/${PR_NUMBER} | jq -r '"submitter=" + .user.login' | tee -a $GITHUB_OUTPUT
+
+      - name: Search for added line in changelog
+        env:
+          PR_SUBMITTER: ${{ steps.get-submitter.outputs.submitter }}
+        run: |
+          ADDED=$(git diff -U0 "origin/${PR_BASE}" HEAD -- CHANGELOG.md | grep -P '^\+[^\+].+$')
+          echo "Added lines in CHANGELOG.md:"
+          echo "$ADDED"
+          echo "Grepping for PR info (see CONTRIBUTING.md):"
+          grep "#${PR_NUMBER}\\b.*${PR_SUBMITTER}\\b" <<< "$ADDED"

.gitignore

@@ -2,6 +2,7 @@
 **/*.rs.bk
 
 # Generated files
+/assets/completions/_bat.ps1
 /assets/completions/bat.bash
 /assets/completions/bat.fish
 /assets/completions/bat.zsh

.gitmodules

@@ -65,11 +65,8 @@
 	path = assets/themes/onehalf
 	url = https://github.com/sonph/onehalf
 [submodule "assets/syntaxes/JavaScript (Babel)"]
-	path = assets/syntaxes/02_Extra/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
@@ -92,7 +89,7 @@
 	path = assets/themes/sublime-snazzy
 	url = https://github.com/greggb/sublime-snazzy
 [submodule "assets/syntaxes/Assembly (ARM)"]
-	path = assets/syntaxes/02_Extra/Assembly (ARM)
+	path = assets/syntaxes/02_Extra/Assembly_(ARM)
 	url = https://github.com/tvi/Sublime-ARM-Assembly
 [submodule "assets/syntaxes/protobuf-syntax-highlighting"]
 	path = assets/syntaxes/02_Extra/Protobuf
@@ -111,17 +108,11 @@
 	path = assets/syntaxes/02_Extra/Fish
 	url = https://github.com/Phidica/sublime-fish.git
 [submodule "assets/syntaxes/Org mode"]
-	path = assets/syntaxes/02_Extra/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
-[submodule "assets/syntaxes/hosts"]
-	path = assets/syntaxes/02_Extra/hosts
-	url = https://github.com/brandonwamboldt/sublime-hosts
 [submodule "assets/syntaxes/ssh-config"]
 	path = assets/syntaxes/02_Extra/ssh-config
 	url = https://github.com/robballou/sublimetext-sshconfig.git
@@ -148,7 +139,7 @@
 	path = assets/themes/dracula-sublime
 	url = https://github.com/dracula/sublime.git
 [submodule "assets/syntaxes/HTML (Twig)"]
-	path = assets/syntaxes/02_Extra/HTML (Twig)
+	path = assets/syntaxes/02_Extra/HTML_(Twig)
 	url = https://github.com/Anomareh/PHP-Twig.tmbundle.git
 [submodule "assets/themes/Nord-sublime"]
 	path = assets/themes/Nord-sublime
@@ -183,7 +174,7 @@
 	url = https://github.com/euler0/sublime-glsl
 [submodule "assets/syntaxes/02_Extra/Nginx"]
 	path = assets/syntaxes/02_Extra/Nginx
-	url = https://github.com/brandonwamboldt/sublime-nginx
+	url = https://github.com/SublimeText/nginx
 [submodule "assets/syntaxes/02_Extra/Apache"]
 	path = assets/syntaxes/02_Extra/Apache
 	url = https://github.com/colinta/ApacheConf.tmLanguage
@@ -202,7 +193,7 @@
 	branch = bat-source
 [submodule "assets/syntaxes/02_Extra/Lean"]
 	path = assets/syntaxes/02_Extra/Lean
-	url = https://github.com/leanprover/vscode-lean.git
+	url = https://github.com/leanprover/vscode-lean4.git
 [submodule "assets/syntaxes/02_Extra/Zig"]
 	path = assets/syntaxes/02_Extra/Zig
 	url = https://github.com/ziglang/sublime-zig-language.git
@@ -230,3 +221,60 @@
 [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
+[submodule "assets/syntaxes/02_Extra/CFML"]
+	path = assets/syntaxes/02_Extra/CFML
+	url = https://github.com/jcberquist/sublimetext-cfml.git
+[submodule "assets/syntaxes/02_Extra/Idris2"]
+	path = assets/syntaxes/02_Extra/Idris2
+	url = https://github.com/buzden/sublime-syntax-idris2
+[submodule "assets/syntaxes/02_Extra/GDScript-sublime"]
+	path = assets/syntaxes/02_Extra/GDScript-sublime
+	url = https://github.com/beefsack/GDScript-sublime
+[submodule "assets/syntaxes/02_Extra/sublime-odin"]
+	path = assets/syntaxes/02_Extra/sublime-odin
+	url = https://github.com/odin-lang/sublime-odin
+[submodule "assets/syntaxes/02_Extra/typst-syntax-highlight"]
+	path = assets/syntaxes/02_Extra/typst-syntax-highlight
+	url = https://github.com/hyrious/typst-syntax-highlight
+[submodule "assets/themes/Catppuccin"]
+	path = assets/themes/Catppuccin
+	url = https://github.com/SchweGELBin/catppuccin-bat-sub.git
+[submodule "assets/syntaxes/02_Extra/SmartVHDL"]
+	path = assets/syntaxes/02_Extra/SmartVHDL
+	url = https://github.com/TheClams/SmartVHDL
+[submodule "assets/syntaxes/02_Extra/hosts"]
+	path = assets/syntaxes/02_Extra/hosts
+	url = https://github.com/tijn/hosts.tmLanguage

CHANGELOG.md

@@ -1,18 +1,383 @@
 # unreleased
 
 ## Features
+- Add build for windows/ARM64 platform. #3190 (@alcroito)
 
-- `$BAT_CONFIG_DIR` is now a recognized environment variable. It has precedence over `$XDG_CONFIG_HOME`, see #1727 (@billrisher)
+- Add paging to `--list-themes`, see PR #3239 (@einfachIrgendwer0815)
+- Support negative relative line ranges, e.g. `bat -r :-10` / `bat -r='-10:'`, see #3068 (@ajesipow)
+- Support context in line ranges, e.g. `bat -r 30::5` /  `bat -r 30:40:5`, see #3345 (@cavanaug)
 
 ## Bugfixes
 
-- Python syntax highlighting no longer suffers from abysmal performance in specific scenarios. See #1688 (@keith-hall)
+- Fix UTF-8 BOM not being stripped for syntax detection, see #3314 (@krikera)
+- Fix `BAT_THEME_DARK` and `BAT_THEME_LIGHT` being ignored, see issue #3171 and PR #3168 (@bash)
+- Prevent `--list-themes` from outputting default theme info to stdout when it is piped, see #3189 (@einfachIrgendwer0815)
+- Rename some submodules to fix Dependabot submodule updates, see issue #3198 and PR #3201 (@victor-gp)
+- Make highlight tests fail when new syntaxes don't have fixtures PR #3255 (@dan-hipschman)
+- Fix crash for multibyte characters in file path, see issue #3230 and PR #3245 (@HSM95)
+- Add missing mappings for various bash/zsh files, see PR #3262 (@AdamGaskins)
+- Send all bat errors to stderr by default, see #3336 (@JerryImMouse)
+- Make --map-syntax target case insensitive to match --language, see #3206 (@keith-hall)
+- Correctly determine the end of the line in UTF16LE/BE input #3369 (@keith-hall)
 
 ## Other
 
-- Load cached assets as fast as integrated assets, see #1753 (@Enselic)
-- Greatly reduce startup time in loop-through mode, e.g. when redirecting output. Instead of *50 ms* - *100 ms*, startup takes *5 ms* - *10 ms*. See #1747 (@Enselic)
+- Update base16 README links to community driven base16 work #2871 (@JamyGolden)
+- Work around build failures when building `bat` from vendored sources #3179 (@dtolnay)
+- CICD: Stop building for x86_64-pc-windows-gnu which fails #3261 (Enselic)
+- CICD:  CICD: replace windows-2019 runners with windows-2025 #3339 (@cyqsimon)
+- Build script: replace string-based codegen with quote-based codegen #3340 (@cyqsimon)
+- Improve code coverage of `--list-languages` parameter #2942 (@sblondon)
+- Only start offload worker thread when there's more than 1 core #2956 (@cyqsimon)
+- Update terminal-colorsaurus (the library used for dark/light detection) to 1.0, see #3347 (@bash)
+- Update console dependency to 0.16, see #3351 (@musicinmybrain)
+- Fixed some typos #3244 (@ssbarnea)
+- Update onig_sys dependency to 69.9.1 to fix a gcc build failure #3400 (@CosmicHorrorDev)
 
+## Syntaxes
+
+- Add syntax mapping for `paru` configuration files #3182 (@cyqsimon)
+- Add support for [Idris 2 programming language](https://www.idris-lang.org/) #3150 (@buzden)
+- Add syntax mapping for `nix`'s '`flake.lock` lockfiles #3196 (@odilf)
+- Improvements to CSV/TSV highlighting, with autodetection of delimiter and support for TSV files, see #3186 (@keith-
+- Improve (Sys)log error highlighting, see #3205 (@keith-hall)
+- Map `ndjson` extension to JSON syntax, see #3209 (@keith-hall)
+- Map files with `csproj`, `vbproj`, `props` and `targets` extensions to XML syntax, see #3213 (@keith-hall)
+- Add debsources syntax to highlight `/etc/apt/sources.list` files, see #3215 (@keith-hall)
+- Add syntax definition and test file for GDScript highlighting, see #3236 (@chetanjangir0)
+- Add syntax test file for Odin highlighting, see #3241 (@chetanjangir0)
+- Update quadlet syntax mapping rules to cover quadlets in subdirectories #3299 (@cyqsimon)
+- Add syntax Typst #3300 (@cskeeters)
+- Map `.mill` files to Scala syntax for Mill build tool configuration files #3311 (@krikera)
+- Add syntax highlighting for VHDL, see #3337 (@JerryImMouse)
+- Add syntax mapping for certbot certificate configuration #3338 (@cyqsimon)
+- Update Lean syntax from Lean 3 to Lean 4 #3322 (@YDX-2147483647)
+- Map `.flatpakref` and `.flatpakrepo` files to INI syntax #3353 (@Ferenc-)
+- Update hosts syntax #3368 (@keith-hall)
+
+## Themes
+
+- Add Catppuccin, see #3317 (@SchweGELBin)
+- Updated Catppuccin, see #3333 (@SchweGELBin)
+- Updated gruvbox, see #3372 (@Nicholas42)
+- Updated GitHub theme, see #3382 (@CosmicHorrorDev)
+
+## `bat` as a library
+
+# v0.25.0
+
+## Features
+
+- Set terminal title to file names when Paging is not Paging::Never #2807 (@Oliver-Looney)
+- `bat --squeeze-blank`/`bat -s` will now squeeze consecutive empty lines, see #1441 (@eth-p) and #2665 (@einfachIrgendwer0815)
+- `bat --squeeze-limit` to set the maximum number of empty consecutive when using `--squeeze-blank`, see #1441 (@eth-p) and #2665 (@einfachIrgendwer0815)
+- `PrettyPrinter::squeeze_empty_lines` to support line squeezing for bat as a library, see #1441 (@eth-p) and #2665 (@einfachIrgendwer0815)
+- Syntax highlighting for JavaScript files that start with `#!/usr/bin/env bun` #2913 (@sharunkumar)
+- `bat --strip-ansi={never,always,auto}` to remove ANSI escape sequences from bat's input, see #2999 (@eth-p)
+- Add or remove individual style components without replacing all styles #2929 (@eth-p)
+- Automatically choose theme based on the terminal's color scheme, see #2896 (@bash)
+- Add option `--binary=as-text` for printing binary content, see issue #2974 and PR #2976 (@einfachIrgendwer0815)
+- Make shell completions available via `--completion <shell>`, see issue #2057 and PR #3126 (@einfachIrgendwer0815)
+- Syntax highlighting for puppet code blocks within Markdown files, see #3152 (@liliwilson)
+
+## Bugfixes
+
+- Fix long file name wrapping in header, see #2835 (@FilipRazek)
+- Fix `NO_COLOR` support, see #2767 (@acuteenvy)
+- Fix handling of inputs with OSC ANSI escape sequences, see #2541 and #2544 (@eth-p)
+- Fix handling of inputs with combined ANSI color and attribute sequences, see #2185 and #2856 (@eth-p)
+- Fix panel width when line 10000 wraps, see #2854 (@eth-p)
+- Fix compile issue of `time` dependency caused by standard library regression #3045 (@cyqsimon)
+- Fix override behavior of --plain and --paging, see issue #2731 and PR #3108 (@einfachIrgendwer0815)
+- Fix bugs in `$LESSOPEN` support, see #2805 (@Anomalocaridid)
+
+## Other
+
+- Upgrade to Rust 2021 edition #2748 (@cyqsimon)
+- Refactor and cleanup build script #2756 (@cyqsimon)
+- Checks changelog has been written to for PRs in CI #2766 (@cyqsimon)
+  - Use GitHub API to get correct PR submitter #2791 (@cyqsimon)
+- Minor benchmark script improvements #2768 (@cyqsimon)
+- Update Arch Linux package URL in README files #2779 (@brunobell)
+- Update and improve `zsh` completion, see #2772 (@okapia)
+- More extensible syntax mapping mechanism #2755 (@cyqsimon)
+- Use proper Architecture for Debian packages built for musl, see #2811 (@Enselic)
+- Pull in fix for unsafe-libyaml security advisory, see #2812 (@dtolnay)
+- Update git-version dependency to use Syn v2, see #2816 (@dtolnay)
+- Update git2 dependency to v0.18.2, see #2852 (@eth-p)
+- Improve performance when color output disabled, see #2397 and #2857 (@eth-p)
+- Relax syntax mapping rule restrictions to allow brace expansion #2865 (@cyqsimon)
+- Apply clippy fixes #2864 (@cyqsimon)
+- Faster startup by offloading glob matcher building to a worker thread #2868 (@cyqsimon)
+- Display which theme is the default one in basic output (no colors), see #2937 (@sblondon)
+- Display which theme is the default one in colored output, see #2838 (@sblondon)
+- Add aarch64-apple-darwin ("Apple Silicon") binary tarballs to releases, see #2967 (@someposer)
+- Update the Lisp syntax, see #2970 (@ccqpein)
+- Use bat's ANSI iterator during tab expansion, see #2998 (@eth-p)
+- Support 'statically linked binary' for aarch64 in 'Release' page, see #2992 (@tzq0301)
+- Update options in shell completions and the man page of `bat`, see #2995 (@akinomyoga)
+- Update nix dev-dependency to v0.29.0, see #3112 (@decathorpe)
+- Bump MSRV to [1.74](https://blog.rust-lang.org/2023/11/16/Rust-1.74.0.html), see #3154 (@keith-hall)
+- Update clircle dependency to remove winapi transitive dependency, see #3113 (@niklasmohrin)
+
+## Syntaxes
+
+- `cmd-help`: scope subcommands followed by other terms, and other misc improvements, see #2819 (@victor-gp)
+- Upgrade JQ syntax, see #2820 (@dependabot[bot])
+- Add syntax mapping for quadman quadlets #2866 (@cyqsimon)
+- Map containers .conf files to TOML syntax #2867 (@cyqsimon)
+- Associate `.xsh` files with `xonsh` syntax that is Python, see #2840 (@anki-code)
+- Associate JSON with Comments `.jsonc` with `json` syntax, see #2795 (@mxaddict)
+- Associate JSON-LD `.jsonld` files with `json` syntax, see #3037 (@vorburger)
+- Associate `.textproto` files with `ProtoBuf` syntax, see #3038 (@vorburger)
+- Associate GeoJSON `.geojson` files with `json` syntax, see #3084 (@mvaaltola)
+- Associate `.aws/{config,credentials}`, see #2795 (@mxaddict)
+- Associate Wireguard config `/etc/wireguard/*.conf`, see #2874 (@cyqsimon)
+- Add support for [CFML](https://www.adobe.com/products/coldfusion-family.html), see #3031 (@brenton-at-pieces)
+- Map `*.mkd` files to `Markdown` syntax, see issue #3060 and PR #3061 (@einfachIrgendwer0815)
+- Add syntax mapping for CITATION.cff, see #3103 (@Ugzuzg)
+- Add syntax mapping for kubernetes config files #3049 (@cyqsimon)
+- Adds support for pipe delimiter for CSV #3115 (@pratik-m)
+- Add syntax mapping for `/etc/pacman.conf` #2961 (@cyqsimon)
+- Associate `uv.lock` with `TOML` syntax, see #3132 (@fepegar)
+
+## Themes
+
+- Patched/improved themes for better Manpage syntax highlighting support, see #2994 (@keith-hall).
+
+## `bat` as a library
+
+- Changes to `syntax_mapping::SyntaxMapping` #2755 (@cyqsimon)
+  - `SyntaxMapping::get_syntax_for` is now correctly public
+  - [BREAKING] `SyntaxMapping::{empty,builtin}` are removed; use `SyntaxMapping::new` instead
+  - [BREAKING] `SyntaxMapping::mappings` is replaced by `SyntaxMapping::{builtin,custom,all}_mappings`
+- Make `Controller::run_with_error_handler`'s error handler `FnMut`, see #2831 (@rhysd)
+- Improve compile time by 20%, see #2815 (@dtolnay)
+- Add `theme::theme` for choosing an appropriate theme based on the
+  terminal's color scheme, see #2896 (@bash)
+  - [BREAKING] Remove `HighlightingAssets::default_theme`. Use `theme::default_theme` instead.
+- Add `PrettyPrinter::print_with_writer` for custom output destinations, see #3070 (@kojix2)
+
+# 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
+
+- 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)
+- Add syntax mapping `*.debdiff` => `diff`, see #2947 (@jacg)
+
+## `bat` as a library
+
+- 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
 
@@ -22,15 +387,29 @@
 - Highlight for `vimrc` and `gvimrc` files, see #1763 (@SuperSandro2000)
 - Syslog highlighting improvements, see #1793 (@scop)
 - Added support for `slim` syntax, see #1693 (@mfinelli)
-
-## New themes
-
+- 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_file_name()` instead. They return a `Result` which is needed for upcoming lazy-loading work to improve startup performance. They also return what `SyntaxSet` the returned `SyntaxReference` belongs to. See #1747, #1755 and #1776 (@Enselic)
+- 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
 

CONTRIBUTING.md

@@ -6,21 +6,42 @@ Thank you for considering to contribute to `bat`!
 
 ## Add an entry to the changelog
 
-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 process much easier and
-therefore helps to get your changes into a new `bat` release faster.
+Keeping the [`CHANGELOG.md`](CHANGELOG.md) file up-to-date makes the release
+process much easier and therefore helps to get your changes into a new `bat`
+release faster. However, not every change to the repository requires a
+changelog entry. Below are a few examples of that.
+
+Please update the changelog if your contribution contains changes regarding
+any of the following:
+  - the behavior of `bat`
+  - syntax mappings
+  - syntax definitions
+  - themes
+  - the build system, linting, or CI workflows
+
+A changelog entry is not necessary when:
+  - updating documentation
+  - fixing typos
+
+>[!NOTE]
+> For PRs, a CI workflow verifies that a suitable changelog entry is
+> added. If such an entry is missing, the workflow will fail. If your
+> changes do not need an entry to the changelog (see above), that
+> workflow failure can be disregarded.
+
+
+### Changelog entry format
 
 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.
 
-Entries follow this format:
+Entries must follow this format:
 ```
 - Short description of what has been changed, see #123 (@user)
 ```
-Here, `#123` is the number of the original issue and/or your pull request.
-Please replace `@user` by your GitHub username.
+Please replace `#123` with the number of your pull request (not issue) and
+`@user` by your GitHub username.
 
 
 ## Development
@@ -33,7 +54,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 +67,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`.

Cargo.toml

@@ -3,13 +3,15 @@ authors = ["David Peter <mail@david-peter.de>"]
 categories = ["command-line-utilities"]
 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"
 repository = "https://github.com/sharkdp/bat"
-version = "0.18.2"
+version = "0.25.0"
 exclude = ["assets/syntaxes/*", "assets/themes/*"]
-build = "build.rs"
-edition = '2018'
+build = "build/main.rs"
+edition = '2021'
+# You are free to bump MSRV as soon as a reason for bumping emerges.
+rust-version = "1.74"
 
 [features]
 default = ["application"]
@@ -24,78 +26,105 @@ application = [
 # Mainly for developers that want to iterate quickly
 # Be aware that the included features might change in the future
 minimal-application = [
-    "atty",
     "clap",
-    "dirs-next",
-    "lazy_static",
+    "etcetera",
     "paging",
     "regex-onig",
     "wild",
 ]
 git = ["git2"] # Support indicating git modifications
-paging = ["shell-words"] # Support applying a pager on the output
-# Add "syntect/plist-load" when https://github.com/trishume/syntect/pull/345 reaches us
-build-assets = ["syntect/yaml-load", "syntect/dump-create"]
+paging = ["shell-words", "grep-cli"] # Support applying a pager on the output
+lessopen = ["execute"] # 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 }
-ansi_term = "^0.12.1"
-ansi_colours = "^1.0"
-console = "0.14.1"
-lazy_static = { version = "1.4", optional = true }
-lazycell = "1.0"
-wild = { version = "2.0", optional = true }
+nu-ansi-term = "0.50.0"
+ansi_colours = "^1.2"
+bincode = "1.0"
+console = "0.16.0"
+flate2 = "1.1"
+once_cell = "1.20"
+thiserror = "2.0"
+wild = { version = "2.2", optional = true }
 content_inspector = "0.2.4"
-encoding = "0.2"
-shell-words = { version = "1.0.0", optional = true }
-unicode-width = "0.1.8"
+shell-words = { version = "1.1.0", optional = true }
+unicode-width = "0.2.1"
 globset = "0.4"
-serde = { version = "1.0", features = ["derive"] }
-serde_yaml = "0.8"
+serde = "1.0"
+serde_derive = "1.0"
+serde_yaml = "0.9.28"
 semver = "1.0"
 path_abs = { version = "0.5", default-features = false }
-clircle = "0.3"
-bugreport = { version = "0.4", optional = true }
-dirs-next = { version = "2.0.0", optional = true }
-grep-cli = "0.1.6"
+clircle = { version = "0.6.1", default-features = false }
+bugreport = { version = "0.5.0", optional = true }
+etcetera = { version = "0.10.0", optional = true }
+grep-cli = { version = "0.1.11", optional = true }
+regex = { version = "1.10.6", optional = true }
+walkdir = { version = "2.5", optional = true }
+bytesize = { version = "1.3.0" }
+encoding_rs = "0.8.35"
+execute = { version = "0.2.13", optional = true }
+terminal-colorsaurus = "1.0"
+unicode-segmentation = "1.12.0"
+itertools = "0.13.0"
 
 [dependencies.git2]
-version = "0.13"
+version = "0.20"
 optional = true
 default-features = false
 
 [dependencies.syntect]
-version = "4.6.0"
+version = "5.2.0"
 default-features = false
-features = ["parsing", "dump-load"]
+features = ["parsing"]
 
 [dependencies.clap]
-version = "2.33"
+version = "4.5.46"
 optional = true
-default-features = false
-features = ["suggestions", "color", "wrap_help"]
+features = ["wrap_help", "cargo"]
 
-[dependencies.error-chain]
-version = "0.12"
-default-features = false
+[target.'cfg(target_os = "macos")'.dependencies]
+home = "0.5.9"
+plist = "1.7.0"
 
 [dev-dependencies]
-assert_cmd = "1.0.8"
-serial_test = "0.5.1"
-predicates = "2.0.1"
+assert_cmd = "2.0.12"
+expect-test = "1.5.0"
+serial_test = { version = "2.0.0", default-features = false }
+predicates = "3.1.3"
 wait-timeout = "0.2.0"
-tempfile = "3.2.0"
+tempfile = "3.16.0"
+serde = { version = "1.0", features = ["derive"] }
 
 [target.'cfg(unix)'.dev-dependencies]
-nix = "0.22.0"
+nix = { version = "0.30", default-features = false, features = ["term"] }
 
 [build-dependencies]
-clap = { version = "2.33", optional = true }
+anyhow = "1.0.97"
+indexmap = { version = "2.8.0", features = ["serde"] }
+itertools = "0.14.0"
+once_cell = "1.20"
+prettyplease = "0.2.35"
+proc-macro2 = "1.0.95"
+quote = "1.0.40"
+regex = "1.10.6"
+serde = "1.0"
+serde_derive = "1.0"
+serde_with = { version = "3.12.0", default-features = false, features = ["macros"] }
+syn = { version = "2.0.104", features = ["full"] }
+toml = { version = "0.9.1", features = ["preserve_order"] }
+walkdir = "2.5"
+
+[build-dependencies.clap]
+version = "4.5.46"
+optional = true
+features = ["wrap_help", "cargo"]
 
 [profile.release]
 lto = true
+strip = true
 codegen-units = 1

LICENSE-MIT

@@ -1,4 +1,4 @@
-Copyright (c) 2018-2021 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

NOTICE

@@ -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.

README.md

@@ -12,7 +12,31 @@
   <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>
+
+<p>
+<a href="https://www.warp.dev/bat">
+  <img src="doc/sponsors/warp-logo.png" width="200" alt="Warp">
+  <br>
+  <strong>Warp, the intelligent terminal</strong>
+  <br>
+  <sub>Available on MacOS, Linux, Windows</sub>
+</a>
+</p><p>
+<a href="https://graphite.dev/?utm_source=github&utm_medium=repo&utm_campaign=bat">
+  <img src="doc/sponsors/graphite-logo.jpeg" width="200" alt="Graphite">
+  <br>
+  <strong>Graphite is the AI developer productivity platform helping<br>teams on GitHub ship higher quality software, faster</strong>
+</a>
 </p>
 
 ### Syntax highlighting
@@ -38,7 +62,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.
 
@@ -52,13 +76,13 @@ Whenever `bat` detects a non-interactive terminal (i.e. when you pipe into anoth
 Display a single file on the terminal
 
 ```bash
-> bat README.md
+bat README.md
 ```
 
 Display multiple files at once
 
 ```bash
-> bat src/*.rs
+bat src/*.rs
 ```
 
 Read from stdin, determine the syntax automatically (note, highlighting will
@@ -66,18 +90,18 @@ only work if the syntax can be determined from the first line of the file,
 usually through a shebang such as `#!/bin/sh`)
 
 ```bash
-> curl -s https://sh.rustup.rs | bat
+curl -s https://sh.rustup.rs | bat
 ```
 
 Read from stdin, specify the language explicitly
 
 ```bash
-> yaml2json .travis.yml | json_pp | bat -l json
+yaml2json .travis.yml | json_pp | bat -l json
 ```
 
 Show and highlight non-printable characters:
 ```bash
-> bat -A /etc/hosts
+bat -A /etc/hosts
 ```
 
 Use it as a `cat` replacement:
@@ -97,21 +121,25 @@ bat f - g  # output 'f', then stdin, then 'g'.
 #### `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`
+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 {}'
+fzf --preview "bat --color=always --style=numbers --line-range=:500 {}"
 ```
-For more information, see [`fzf`s `README`](https://github.com/junegunn/fzf#preview-window).
+
+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
 ```
@@ -127,9 +155,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.
 
@@ -137,6 +167,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
 ```
@@ -147,7 +178,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 -z | xargs -0 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).
@@ -170,41 +201,90 @@ bat main.cpp | xclip
 `MANPAGER` environment variable:
 
 ```bash
-export MANPAGER="sh -c 'col -bx | bat -l man -p'"
+export MANPAGER="sh -c 'awk '\''{ gsub(/\x1B\[[0-9;]*m/, \"\", \$0); gsub(/.\x08/, \"\", \$0); print }'\'' | bat -p -lman'"
 man 2 select
 ```
-(replace `bat` by `batcat` if you are on Debian or Ubuntu)
-
-It might also be necessary to set `MANROFFOPT="-c"` if you experience
-formatting problems.
+(replace `bat` with `batcat` if you are on Debian or Ubuntu)
 
 If you prefer to have this bundled in a new command, you can also use [`batman`](https://github.com/eth-p/bat-extras/blob/master/doc/batman.md).
 
-Note that the [Manpage syntax](assets/syntaxes/02_Extra/Manpage.sublime-syntax) is developed in this repository and still needs some work.
+> [!WARNING]  
+> This will [not work](https://github.com/sharkdp/bat/issues/1145) out of the box with Mandoc's `man` implementation.
+>
+> Please either use `batman`, or convert the shell script to a [shebang executable](https://en.wikipedia.org/wiki/Shebang_(Unix)) and point `MANPAGER` to that.
 
-Also, note that this will [not work](https://github.com/sharkdp/bat/issues/1145) with Mandocs `man` implementation.
+Note that the [Manpage syntax](assets/syntaxes/02_Extra/Manpage.sublime-syntax) is developed in this repository and still needs some work.
 
 #### `prettier` / `shfmt` / `rustfmt`
 
 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`.
 
+#### `Warp`
+
+<a href="https://app.warp.dev/drive/folder/-Bat-Warp-Pack-lxhe7HrEwgwpG17mvrFSz1">
+  <img src="doc/sponsors/warp-pack-header.png" alt="Warp">
+</a>
+
+#### 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'
+```
+
+For `fish`, you can use abbreviations:
+
+```fish
+abbr -a --position anywhere -- --help '--help | bat -plhelp'
+abbr -a --position anywhere -- -h '-h | bat -plhelp'
+```
+
+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`). In cases where you need to use `-h` 
+as a command argument you can prepend `\` to the arguement (eg. `ls \-h`) to escape the aliasing defined above. 
+
+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-cat.svg)](https://repology.org/project/bat-cat/versions)
+<!--
+
+Installation instructions need to:
+* be for widely used systems
+* be non-obvious
+* be from somewhat official sources
+
+-->
+
+[![Packaging status](https://repology.org/badge/vertical-allrepos/bat-cat.svg?columns=3&exclude_unsupported=1)](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
-[Debian](https://packages.debian.org/testing/bat) package release process, and is available
-for Ubuntu as of Eoan 19.10. On Debian `bat` is currently available on the unstable
-"Sid" branch and on the testing branch.
+`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).
 
 If your Ubuntu/Debian installation is new enough you can simply run:
 
 ```bash
-apt install bat
+sudo apt install bat
 ```
 
 **Important**: If you install `bat` this way, please note that the executable may be installed as `batcat` instead of `bat` (due to [a name
@@ -214,6 +294,11 @@ mkdir -p ~/.local/bin
 ln -s /usr/bin/batcat ~/.local/bin/bat
 ```
 
+an example alias for `batcat` as `bat`:
+```bash
+alias bat="batcat"
+```
+
 ### On Ubuntu (using most recent `.deb` packages)
 *... and other Debian-based Linux distributions.*
 
@@ -222,7 +307,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.18.2_amd64.deb  # adapt version number and architecture
+sudo dpkg -i bat_0.18.3_amd64.deb  # adapt version number and architecture
 ```
 
 ### On Alpine Linux
@@ -236,7 +321,7 @@ apk add bat
 
 ### On Arch Linux
 
-You can install [the `bat` package](https://www.archlinux.org/packages/community/x86_64/bat/)
+You can install [the `bat` package](https://www.archlinux.org/packages/extra/x86_64/bat/)
 from the official sources:
 
 ```bash
@@ -260,20 +345,6 @@ from the official sources:
 emerge sys-apps/bat
 ```
 
-### On Void Linux
-
-You can install `bat` via xbps-install:
-```bash
-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:
@@ -289,6 +360,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):
@@ -312,7 +391,7 @@ Existing packages may be available, but are not officially supported and may con
 
 ### 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
@@ -333,7 +412,15 @@ take a look at the ["Using `bat` on Windows"](#using-bat-on-windows) section.
 
 #### Prerequisites
 
-You will need to install the [Visual C++ Redistributable](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads) package.
+You will need to install the [Visual C++ Redistributable](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist#latest-microsoft-visual-c-redistributable-version)
+
+#### 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
 
@@ -363,26 +450,44 @@ 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.45 or
+If you want to build `bat` from source, you need Rust 1.74.0 or
 higher. You can then use `cargo` to build everything:
 
+#### From local source
+```bash
+cargo install --path . --locked
+```
+> [!NOTE]
+> The `--path .` above specifies the directory of the source code and NOT where `bat` will be installed.
+> For more information see the docs for [`cargo install`](https://doc.rust-lang.org/cargo/commands/cargo-install.html).
+
+#### From `crates.io`
 ```bash
 cargo install --locked bat
 ```
 
 Note that additional files like the man page or shell completion
-files can not be installed in this way. They will be generated by `cargo` and should be available in the cargo target folder (under `build`).
+files can not be installed automatically in both these ways.
+If installing from a local source, they will be generated by `cargo`
+and should be available in the cargo target folder under `build`.
+
+Furthermore, shell completions are also available by running:
+```bash
+bat --completion <shell>
+# see --help for supported shells
+```
 
 ## Customization
 
 ### Highlighting theme
 
 Use `bat --list-themes` to get a list of all available themes for syntax
-highlighting. To select the `TwoDark` theme, call `bat` with the
-`--theme=TwoDark` option or set the `BAT_THEME` environment variable to
+highlighting. By default, `bat` uses `Monokai Extended` or `Monokai Extended Light`
+for dark and light themes respectively. To select the `TwoDark` theme, call `bat`
+with the `--theme=TwoDark` option or set the `BAT_THEME` environment variable to
 `TwoDark`. Use `export BAT_THEME="TwoDark"` in your shell's startup file to
-make the change permanent. Alternatively, use `bat`s
-[configuration file](https://github.com/sharkdp/bat#configuration-file).
+make the change permanent. Alternatively, use `bat`'s
+[configuration file](#configuration-file).
 
 If you want to preview the different themes on a custom file, you can use
 the following command (you need [`fzf`](https://github.com/junegunn/fzf) for this):
@@ -390,10 +495,12 @@ the following command (you need [`fzf`](https://github.com/junegunn/fzf) for thi
 bat --list-themes | fzf --preview="bat --theme={} --color=always /path/to/file"
 ```
 
-`bat` looks good on a dark background by default. However, if your terminal uses a
-light background, some themes like `GitHub` or `OneHalfLight` will work better for you.
+`bat` automatically picks a fitting theme depending on your terminal's background color.
+You can use the `--theme-dark` / `--theme-light` options or the `BAT_THEME_DARK` / `BAT_THEME_LIGHT` environment variables
+to customize the themes used. This is especially useful if you frequently switch between dark and light mode.
+
 You can also use a custom theme by following the
-['Adding new themes' section below](https://github.com/sharkdp/bat#adding-new-themes).
+['Adding new themes' section below](#adding-new-themes).
 
 ### 8-bit themes
 
@@ -402,12 +509,12 @@ even when truecolor support is available:
 
 - `ansi` looks decent on any terminal. It uses 3-bit colors: black, red, green,
   yellow, blue, magenta, cyan, and white.
-- `base16` is designed for [base16](https://github.com/chriskempson/base16) terminal themes. It uses
+- `base16` is designed for [base16](https://github.com/tinted-theming/home) 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).
-- `base16-256` is designed for [base16-shell](https://github.com/chriskempson/base16-shell).
+  [base16 styling guidelines](https://github.com/tinted-theming/home/blob/main/styling.md).
+- `base16-256` is designed for [tinted-shell](https://github.com/tinted-theming/tinted-shell).
   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.
+  because you have a 256-color terminal but are not using tinted-shell.
 
 Although these themes are more restricted, they have three advantages over truecolor themes. They:
 
@@ -417,11 +524,21 @@ Although these themes are more restricted, they have three advantages over truec
 
 ### Output style
 
-You can use the `--style` option to control the appearance of `bat`s output.
+You can use the `--style` option to control the appearance of `bat`'s output.
 You can use `--style=numbers,changes`, for example, to show only Git changes
 and line numbers but no grid and no file header. Set the `BAT_STYLE` environment
-variable to make these changes permanent or use `bat`s
-[configuration file](https://github.com/sharkdp/bat#configuration-file).
+variable to make these changes permanent or use `bat`'s
+[configuration file](#configuration-file).
+
+>[!tip]
+> If you specify a default style in `bat`'s config file, you can change which components
+> are displayed during a single run of `bat` using the `--style` command-line argument.
+> By prefixing a component with `+` or `-`, it can be added or removed from the current style.
+>
+> For example, if your config contains `--style=full,-snip`, you can run bat with
+> `--style=-grid,+snip` to remove the grid and add back the `snip` component.
+> Or, if you want to override the styles completely, you use `--style=numbers` to
+> only show the line numbers.
 
 ### Adding new syntaxes / language definitions
 
@@ -468,6 +585,8 @@ syntax:
 ### Adding new themes
 
 This works very similar to how we add new syntax definitions.
+> [!NOTE]
+> Themes are stored in [`.tmTheme` files](https://www.sublimetext.com/docs/color_schemes_tmtheme.html).
 
 First, create a folder with the new syntax highlighting themes:
 ```bash
@@ -482,6 +601,8 @@ bat cache --build
 ```
 
 Finally, use `bat --list-themes` to check if the new themes are available.
+> [!NOTE]
+> `bat` uses the name of the `.tmTheme` file for the theme's name. 
 
 ### Adding or changing file type associations
 
@@ -491,8 +612,9 @@ command line option. The option takes an argument of the form `pattern:syntax` w
 the absolute file path. The `syntax` part is the full name of a supported language
 (use `bat --list-languages` for an overview).
 
-Note: You probably want to use this option as an entry in `bat`s configuration file instead
-of passing it on the command line (see below).
+**Note:** You probably want to use this option as [an entry in `bat`'s configuration file](#configuration-file)
+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
@@ -517,31 +639,52 @@ 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.
+>[!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:
 
 ```bash
-export BAT_PAGER="less -RF"
+export BAT_PAGER="less -RFK"
 ```
 
-Instead of using environment variables, you can also use `bat`s [configuration file](https://github.com/sharkdp/bat#configuration-file) to configure the pager (`--pager` option).
+Instead of using environment variables, you can also use `bat`'s [configuration file](#configuration-file) to configure the pager (`--pager` option).
 
-**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`.
+### Using `less` as a pager
 
-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.
+When using `less` as a pager, `bat` will automatically pass extra options along to `less`
+to improve the experience. Specifically, `-R`/`--RAW-CONTROL-CHARS`, `-F`/`--quit-if-one-screen`,
+`-K`/`--quit-on-intr` and under certain conditions, `-X`/`--no-init` and/or `-S`/`--chop-long-lines`.
+
+>[!IMPORTANT]
+> These options will not be added if:
+> - The pager is not named `less`.
+> - The `--pager` argument contains any command-line arguments (e.g. `--pager="less -R"`).
+> - The `BAT_PAGER` environment variable contains any command-line arguments (e.g. `export BAT_PAGER="less -R"`)
+>
+> The `--quit-if-one-screen` option will not be added when:
+> - The `--paging=always` argument is used.
+> - The `BAT_PAGING` environment is set to `always`.
+
+The `-R` option is needed to interpret ANSI colors correctly.
+
+The `-F` option 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 `-K` option instructs `less` to exit immediately when an interrupt signal is received.
+This is useful to ensure that `less` quits together with `bat` on SIGINT.
+
+The `-X` option is needed to fix a bug with the `--quit-if-one-screen` feature in versions
+of `less` older than version 530. Unfortunately, it also breaks mouse-wheel support in `less`.
+If you want to enable mouse-wheel scrolling on older versions of `less` and do not mind losing
+the quit-if-one-screen feature, you can set the pager (via `--pager` or `BAT_PAGER`) to `less -R`.
+For `less` 530 or newer, it should work out of the box.
+
+The `-S` option is added when `bat`'s `-S`/`--chop-long-lines` option is used. This tells `less`
+to truncate any lines larger than the terminal width.
 
 ### Indentation
 
@@ -555,12 +698,40 @@ sidebar. Calling `bat` with `--tabs=0` will override it and let tabs be consumed
 
 ### Dark mode
 
-If you make use of the dark mode feature in macOS, you might want to configure `bat` to use a different
+If you make use of the dark mode feature in **macOS**, you might want to configure `bat` to use a different
 theme based on the OS theme. The following snippet uses the `default` theme when in the _dark mode_
 and the `GitHub` theme when in the _light mode_.
 
 ```bash
-alias cat="bat --theme=\$(defaults read -globalDomain AppleInterfaceStyle &> /dev/null && echo default || echo GitHub)"
+alias cat="bat --theme auto:system --theme-dark default --theme-light GitHub"
+```
+
+The same dark mode feature is now available in **GNOME** and affects the `org.gnome.desktop.interface color-scheme` setting. The following code converts the above to use said setting.
+
+```bash
+# .bashrc
+sys_color_scheme_is_dark() {
+    condition=$(gsettings get org.gnome.desktop.interface color-scheme)
+    condition=$(echo "$condition" | tr -d "[:space:]'")
+    if [ $condition == "prefer-dark" ]; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+bat_alias_wrapper() {
+    #get color scheme
+    sys_color_scheme_is_dark
+    if [[ $? -eq 0 ]]; then
+        # bat command with dark color scheme
+        bat --theme=default "$@"
+    else
+        # bat command with light color scheme
+        bat --theme=GitHub "$@"
+    fi
+}
+alias cat='bat_alias_wrapper'
 ```
 
 
@@ -568,14 +739,15 @@ 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
 ```
 
-Alternatively, you can use the `BAT_CONFIG_PATH` environment variable to point `bat` to a
-non-default location of the configuration file:
+Alternatively, you can use `BAT_CONFIG_PATH` or `BAT_CONFIG_DIR` environment variables to point `bat`
+to a non-default location of the configuration file or the configuration directory respectively:
 ```bash
-export BAT_CONFIG_PATH="/path/to/bat.conf"
+export BAT_CONFIG_PATH="/path/to/bat/bat.conf"
+export BAT_CONFIG_DIR="/path/to/bat"
 ```
 
 A default configuration file can be created with the `--generate-config-file` option.
@@ -583,6 +755,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.
@@ -598,7 +774,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++"
 ```
 
@@ -622,11 +798,9 @@ your `PATH` or [define an environment variable](#using-a-different-pager). The [
 Windows 10 natively supports colors in both `conhost.exe` (Command Prompt) and PowerShell since
 [v1511](https://en.wikipedia.org/wiki/Windows_10_version_history#Version_1511_(November_Update)), as
 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/).
+[Cmder](http://cmder.app/), which includes [ConEmu](https://conemu.github.io/).
 
-**Note:** The Git and MSYS versions of `less` do not correctly interpret colors on Windows. 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.
+**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.
 
 ### Cygwin
 
@@ -650,6 +824,18 @@ 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.
+
+If your version of `bat` supports the `--strip-ansi=auto` option, it can be used to remove such sequences
+before syntax highlighting. Alternatively, you may disable both syntax highlighting and wrapping by
+passing the `--color=never --wrap=never` options to `bat`.
+
+> [!NOTE]
+> The `auto` option of `--strip-ansi` avoids removing escape sequences when the syntax is plain text.
+
 ### Terminals & colors
 
 `bat` handles terminals *with* and *without* truecolor support. However, the colors in most syntax
@@ -701,7 +887,7 @@ bash assets/create.sh
 cargo install --path . --locked --force
 ```
 
-If you want to build an application that uses `bat`s pretty-printing
+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.
@@ -719,7 +905,7 @@ Take a look at the [`CONTRIBUTING.md`](CONTRIBUTING.md) guide.
 
 ## Security vulnerabilities
 
-Please contact [David Peter](https://david-peter.de/) via email if you want to report a vulnerability in `bat`.
+See [`SECURITY.md`](SECURITY.md).
 
 ## Project goals and alternatives
 
@@ -734,7 +920,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-2021 [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.
 

SECURITY.md

@@ -0,0 +1,3 @@
+# Security Vulnerabilities
+
+To report a security vulnerability, please contact [David Peter](https://david-peter.de/) via email.

assets/completions/_bat.ps1.in

@@ -0,0 +1,196 @@
+
+using namespace System.Management.Automation
+using namespace System.Management.Automation.Language
+
+Register-ArgumentCompleter -Native -CommandName '{{PROJECT_EXECUTABLE}}' -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    $ArrayStyle      = @('default', 'auto', 'full', 'plain', 'changes', 'header', 'header-filename', 'header-filesize', 'grid', 'rule', 'numbers', 'snip')
+    $ArrayCompletion = @('bash', 'fish', 'zsh', 'ps1')
+    $ArrayWhen       = @('auto', 'never', 'always')
+    $ArrayYesNo      = @('never', 'always')
+    $ArrayWrap       = @('always', 'never', 'character')
+    $ArrayBinary     = @('no-printing', 'as-text')
+    $ArrayPrint      = @('unicode', 'caret')
+
+    function Get-MyThemes(){
+        $themes = {{PROJECT_EXECUTABLE}} --list-themes | ForEach-Object {$_  -replace "^(.*)$", '''$1'''} | select-object
+        return $themes
+    }
+
+    function Get-MyLanguages(){
+        $themes = {{PROJECT_EXECUTABLE}} --list-languages | ForEach-Object{[pscustomobject]@{MyParameter=$_.Substring(0,$_.IndexOf(":")).Trim();MyDescription=$_.Substring($_.IndexOf(":")+1)}} | select-object
+        return $themes
+    }
+
+    $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('-') -or
+                $element.Value -eq $wordToComplete) {
+                break
+        }
+        $element.Value
+    }) -join ';'
+
+    $completions = @(switch -Wildcard ($command) {
+        '*;--help' {
+            break
+        }
+        '*;--version' {
+            break
+        }
+        '*;--acknowledgements' {
+            break
+        }
+        '*;--language' {
+            Get-MyLanguages |
+            ForEach-Object {[CompletionResult]::new(($_.MyParameter -replace "^(.*)$", '''$1'''), $_.MyParameter, [CompletionResultType]::ParameterName, $_.MyDescription ?? '_no value_')}
+            break
+        }
+        '*;--theme' {
+            Get-MyThemes |
+            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterName, $_)}
+            break
+        }
+        '*;--binary' {
+            $ArrayBinary |
+            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterValue, $_)}
+            break
+        }
+        '*;--style' {
+            $ArrayStyle |
+            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterValue, $_)}
+            break
+        }
+        '*;--wrap' {
+            $ArrayWrap |
+            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterValue, $_)}
+            break
+        }
+        '*;--color' {
+            $ArrayWhen |
+            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterValue, $_)}
+            break
+        }
+        '*;--italic-text' {
+            $ArrayYesNo |
+            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterValue, $_)}
+            break
+        }
+        '*;--paging' {
+            $ArrayWhen |
+            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterValue, $_)}
+            break
+        }
+        '*;--decorations' {
+            $ArrayWhen |
+            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterValue, $_)}
+            break
+        }
+        '*;--completion' {
+            $ArrayCompletion |
+            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterValue, $_)}
+            break
+        }
+        '*;--strip-ansi' {
+            $ArrayWhen |
+            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterValue, $_)}
+            break
+        }
+        '*;--nonprintable-notation' {
+            $ArrayPrint |
+            ForEach-Object {[System.Management.Automation.CompletionResult]::new($_, $_, [CompletionResultType]::ParameterValue, $_)}
+            break
+        }
+        '*;--generate-config-file' {
+            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
+        }
+        default {
+        #   [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*, 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('--theme-dark'            , 'themedark'             , [CompletionResultType]::ParameterName, 'Set the color theme for syntax highlighting for dark backgrounds.')
+            [CompletionResult]::new('--theme-light'           , 'themelight'            , [CompletionResultType]::ParameterName, 'Set the color theme for syntax highlighting for light backgrounds.')
+            [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('--nonprintable-notation' , 'nonprintable-notation' , [CompletionResultType]::ParameterName, 'Set notation for non-printable characters. (unicode, caret)')
+            [CompletionResult]::new('--chop-long-lines'       , 'chop-long-lines'       , [CompletionResultType]::ParameterName, 'Truncate all lines longer than screen width. Alias for ''--wrap=never''.')
+            [CompletionResult]::new('--binary'                , 'binary'                , [CompletionResultType]::ParameterName, 'How to treat binary content. (*no-printing*, as-text)')
+            [CompletionResult]::new('--ignored-suffix'        , 'ignored-suffix'        , [CompletionResultType]::ParameterName, 'Ignore extension. For example: ''bat --ignored-suffix ".dev" my_file.json.dev'' will use JSON syntax, and ignore ''.dev''')
+            [CompletionResult]::new('--squeeze-blank'         , 'squeeze-blank'         , [CompletionResultType]::ParameterName, 'Squeeze consecutive empty lines into a single empty line.')
+            [CompletionResult]::new('--squeeze-limit'         , 'squeeze-limit'         , [CompletionResultType]::ParameterName, 'Set the maximum number of consecutive empty lines to be printed.')
+            [CompletionResult]::new('--strip-ansi'            , 'strip-ansi'            , [CompletionResultType]::ParameterName, 'Specify when to strip ANSI escape sequences from the input. The automatic mode will remove escape sequences unless the syntax highlighting language is plain text. (auto, always, *never*).')
+        #   [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('--completion'            , 'completion'            , [CompletionResultType]::ParameterName, 'Show shell completion for a certain shell. [possible values: bash, fish, zsh, ps1]')
+            [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('--acknowledgements'      , 'acknowledgements'      , [CompletionResultType]::ParameterName, 'Show acknowledgements.')
+            [CompletionResult]::new('--set-terminal-title'    , 'set-terminal-title'    , [CompletionResultType]::ParameterName, 'Sets terminal title to filenames when using a pager.')
+            [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.')
+            break
+        }
+    })
+
+    $completions.Where{ $_.CompletionText -like "$wordToComplete*" } |
+        Sort-Object -Property CompletionText
+}

assets/completions/bat.bash.in

@@ -2,9 +2,43 @@
 
 # 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 cword split
-	_init_completion -s || return 0
+	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
@@ -14,7 +48,12 @@ _bat() {
 			;;
 		esac
 		COMPREPLY=($(compgen -W "
-			--build --clear --source --target --blank --help
+			--build
+			--clear
+			--source
+			--target
+			--blank
+			--help
 		" -- "$cur"))
 		return 0
 	fi
@@ -27,13 +66,28 @@ _bat() {
 				printf "%s\n" "$lang"
 			done
 		)" -- "$cur"))
-		compopt -o filenames  # for escaping
+                __bat_escape_completions
 		return 0
 		;;
-	-H | --highlight-line | --diff-context | --tabs | --terminal-width | \
-	-m | --map-syntax | --style | --line-range | -h | --help | -V | \
-	--version | --diagnostic | --config-file | --config-dir | \
-	--cache-dir | --generate-config-file)
+	-H | --highlight-line | \
+	--diff-context | \
+	--tabs | \
+	--terminal-width | \
+	-m | --map-syntax | \
+	--ignored-suffix | \
+	--list-themes | \
+	--squeeze-limit | \
+	--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
@@ -59,30 +113,97 @@ _bat() {
 		return 0
 		;;
 	--theme)
+    	local IFS=$'\n'
+    	COMPREPLY=($(compgen -W "auto${IFS}auto:always${IFS}auto:system${IFS}dark${IFS}light${IFS}$("$1" --list-themes)" -- "$cur"))
+                    __bat_escape_completions
+    	return 0
+    	;;
+	--theme-dark | \
+	--theme-light)
 		local IFS=$'\n'
 		COMPREPLY=($(compgen -W "$("$1" --list-themes)" -- "$cur"))
-		compopt -o filenames  # for escaping
+                __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 --paging --pager --map-syntax --theme
-			--list-themes --style --line-range --list-languages
-			--help --version --force-colorization --unbuffered
-			--diagnostic --config-file --config-dir --cache-dir
+			--show-all
+			--plain
+			--language
+			--highlight-line
+			--file-name
+			--diff
+			--diff-context
+			--tabs
+			--wrap
+			--chop-long-lines
+			--terminal-width
+			--number
+			--color
+			--italic-text
+			--decorations
+			--force-colorization
+			--paging
+			--pager
+			--map-syntax
+			--ignored-suffix
+			--theme
+			--theme-dark
+			--theme-light
+			--list-themes
+			--squeeze-blank
+			--squeeze-limit
+			--style
+			--line-range
+			--list-languages
+			--lessopen
+			--diagnostic
+			--acknowledgements
+			--set-terminal-title
+			--help
+			--version
+			--cache-dir
+			--config-dir
+			--config-file
 			--generate-config-file
+			--no-config
+			--no-custom-assets
+			--no-lessopen
 		" -- "$cur"))
 		return 0
 	fi
 
 	_filedir
-	((cword == 1)) && COMPREPLY+=($(compgen -W cache -- "$cur"))
-
+	
+	## 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}}

assets/completions/bat.fish.in

@@ -1,78 +1,244 @@
 # 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:
-function __{{PROJECT_EXECUTABLE}}_autocomplete_languages --description "A helper function used by "(status filename)
-	{{PROJECT_EXECUTABLE}} --list-languages | awk -F':' '
-		{
-			lang=$1
-			split($2, exts, ",")
+# `bat` is `batcat` on Debian and Ubuntu
+set bat {{PROJECT_EXECUTABLE}}
 
-			for (i in exts) {
-				ext=exts[i]
-				if (ext !~ /[A-Z].*/ && ext !~ /^\..*rc$/) {
-					print ext"\t"lang
-				}
-			}
-		}
-	' | sort
+# Helper functions:
+
+function __bat_complete_files -a token
+    # 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"
 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
+'
+
+set -l special_themes '
+    auto\tdefault,\ Choose\ a\ theme\ based\ on\ dark\ or\ light\ mode
+    auto:always\tChoose\ a\ theme\ based\ on\ dark\ or\ light\ mode
+    auto:system\tChoose\ a\ theme\ based\ on\ dark\ or\ light\ mode
+    dark\tUse\ the\ theme\ specified\ by\ --theme-dark
+    light\tUse\ the\ theme\ specified\ by\ --theme-light
+'
+
 # 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 cache-dir -f -d "Show bat's cache directory" -n __fish_is_first_arg
 
-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 color -x -a "$color_opts" -d "When to use colored output" -n __bat_no_excl_args
 
-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-dir -f -d "Display location of configuration directory" -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 config-file -f -d "Display location of configuration file" -n __fish_is_first_arg
 
-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 decorations -x -a "$decorations_opts" -d "When to use --style decorations" -n __bat_no_excl_args
 
-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 -l diagnostic -d "Print diagnostic info for bug reports" -n __fish_is_first_arg
 
-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 -s d -l diff -d "Only show lines with Git changes" -n __bat_no_excl_args
 
-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 diff-context -x -d "Show N context lines around Git changes" -n "__fish_seen_argument -s d -l diff"
 
-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 -l generate-config-file -f -d "Generates a default configuration file" -n __fish_is_first_arg
 
-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 -l file-name -x -d "Specify the display name" -n __bat_no_excl_args
 
-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 -s f -l force-colorization -d "Force color and decorations" -n __bat_no_excl_args
 
-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 -d "Print a concise overview" -n __fish_is_first_arg
 
-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 help -f -d "Print all help information" -n __fish_is_first_arg
 
-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 -s H -l highlight-line -x -d "Highlight line(s) N[:M]" -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 -l ignored-suffix -x -d "Ignore extension" -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 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 A -l show-all -d "Show non-printable characters like space/tab/newline" -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}} -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 lessopen -d "Enable the $LESSOPEN preprocessor" -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 -s r -l line-range -x -d "Only print lines [M]:[N] (either optional)" -n __bat_no_excl_args
 
-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 -l list-languages -f -d "List syntax highlighting languages" -n __fish_is_first_arg
 
-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 -l list-themes -f -d "List syntax highlighting themes" -n __fish_is_first_arg
 
-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 -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}} -s V -l version -d "Show version information" -n "not __fish_seen_subcommand_from cache"
+complete -c $bat -l no-config -d "Do not use the configuration file"
 
-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 -l no-custom-assets -d "Do not load custom assets"
+
+complete -c $bat -l no-lessopen -d "Disable the $LESSOPEN preprocessor if enabled (overrides --lessopen)"
+
+complete -c $bat -s n -l number -d "Only show line numbers, no other decorations" -n __bat_no_excl_args
+
+complete -c $bat -l pager -x -a "$pager_opts" -d "Which pager to use" -n __bat_no_excl_args
+
+complete -c $bat -l paging -x -a "$paging_opts" -d "When to use the pager" -n __bat_no_excl_args
+
+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 "$special_themes(command $bat --list-themes | command cat)" -d "Set the syntax highlighting theme" -n __bat_no_excl_args
+
+complete -c $bat -l theme-dark -x -a "(command $bat --list-themes | command cat)" -d "Set the syntax highlighting theme for dark backgrounds" -n __bat_no_excl_args
+
+complete -c $bat -l theme-light -x -a "(command $bat --list-themes | command cat)" -d "Set the syntax highlighting theme for light backgrounds" -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

assets/completions/bat.zsh.in

@@ -1,19 +1,20 @@
 #compdef {{PROJECT_EXECUTABLE}}
 
-local context state state_descr line
+local curcontext="$curcontext" ret=1
+local -a state state_descr line
 typeset -A opt_args
 
 (( $+functions[_{{PROJECT_EXECUTABLE}}_cache_subcommand] )) ||
 _{{PROJECT_EXECUTABLE}}_cache_subcommand() {
     local -a args
     args=(
-        '(-b --build -c --clear)'{-b,--build}'[Initialize or update the syntax/theme cache]'
-        '(-b --build -c --clear)'{-c,--clear}'[Remove the cached syntax definitions and themes]'
-        '(--source)'--source='[Use a different directory to load syntaxes and themes from]:directory:_files -/'
-        '(--target)'--target='[Use a different directory to store the cached syntax and theme set]:directory:_files -/'
-        '(--blank)'--blank'[Create completely new syntax and theme sets]'
-        '(: -)'{-h,--help}'[Prints help information]'
-        '*: :'
+        '(-b --build -c --clear)'{-b,--build}'[initialize or update the syntax/theme cache]'
+        '(-b --build -c --clear)'{-c,--clear}'[remove the cached syntax definitions and themes]'
+        --source='[specify directory to load syntaxes and themes from]:directory:_files -/'
+        --target='[specify directory to store the cached syntax and theme set in]:directory:_files -/'
+        --blank'[create completely new syntax and theme sets]'
+        --acknowledgements'[build acknowledgements.bin]'
+        '(: -)'{-h,--help}'[show help information]'
     )
 
     _arguments -S -s $args
@@ -23,77 +24,92 @@ _{{PROJECT_EXECUTABLE}}_cache_subcommand() {
 _{{PROJECT_EXECUTABLE}}_main() {
     local -a args
     args=(
-        '(-A --show-all)'{-A,--show-all}'[Show non-printable characters (space, tab, newline, ..)]'
-        '*'{-p,--plain}'[Show plain style (alias for `--style=plain`), repeat twice to disable disable automatic paging (alias for `--paging=never`)]'
-        '(-l --language)'{-l+,--language=}'[Set the language for syntax highlighting]:<language>:->language'
-        '(-H --highlight-line)'{-H,--highlight-line}'[Highlight lines N through M]:<N\:M>...'
-        '(--file-name)'--file-name'[Specify the name to display for a file]:<name>...:_files'
-        '(-d --diff)'--diff'[Only show lines that have been added/removed/modified]'
-        '(--diff-context)'--diff-context'[Include N lines of context around added/removed/modified lines when using `--diff`]:<N> (lines):()'
-        '(--tabs)'--tabs'[Set the tab width to T spaces]:<T> (tab width):()'
-        '(--wrap)'--wrap='[Specify the text-wrapping mode]:<when>:(auto never character)'
-        '(--terminal-width)'--terminal-width'[Explicitly set the width of the terminal instead of determining it automatically]:<width>'
-        '(-n --number)'{-n,--number}'[Show line numbers]'
-        '(--color)'--color='[When to use colors]:<when>:(auto never always)'
-        '(--italic-text)'--italic-text='[Use italics in output]:<when>:(always never)'
-        '(--decorations)'--decorations='[When to show the decorations]:<when>:(auto never always)'
-        '(--paging)'--paging='[Specify when to use the pager]:<when>:(auto never always)'
-        '(-m --map-syntax)'{-m+,--map-syntax=}'[Use the specified syntax for files matching the glob pattern]:<glob\:syntax>...'
-        '(--theme)'--theme='[Set the color theme for syntax highlighting]:<theme>:->theme'
-        '(: --list-themes --list-languages -L)'--list-themes'[Display all supported highlighting themes]'
-        '(--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]'
-        '(: --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'
+        '(-A --show-all)'{-A,--show-all}'[show non-printable characters (space, tab, newline, ..)]'
+        --nonprintable-notation='[specify how to display non-printable characters when using --show-all]:notation:(caret unicode)'
+        \*{-p,--plain}'[show plain style (alias for `--style=plain`), repeat twice to disable automatic paging (alias for `--paging=never`)]'
+        '(-l --language)'{-l+,--language=}'[set the language for syntax highlighting]:language:->languages'
+        \*{-H+,--highlight-line=}'[highlight specified block of lines]:start\:end'
+        \*--file-name='[specify the name to display for a file]:name:_files'
+        '(-d --diff)'--diff'[only show lines that have been added/removed/modified]'
+        --diff-context='[specify lines of context around added/removed/modified lines when using `--diff`]:lines'
+        --tabs='[set the tab width]:tab width [4]'
+        --wrap='[specify the text-wrapping mode]:mode [auto]:(auto never character)'
+        '!(--wrap)'{-S,--chop-long-lines}
+        --terminal-width='[explicitly set the width of the terminal instead of determining it automatically]:width'
+        '(-n --number --diff --diff-context)'{-n,--number}'[show line numbers]'
+        --color='[specify when to use colors]:when:(auto never always)'
+        --italic-text='[use italics in output]:when:(always never)'
+        --decorations='[specify when to show the decorations]:when:(auto never always)'
+        --paging='[specify when to use the pager]:when:(auto never always)'
+        '(-m --map-syntax)'{-m+,--map-syntax=}'[map a glob pattern to an existing syntax name]: :->syntax-maps'
+        '(--theme)'--theme='[set the color theme for syntax highlighting]:theme:->theme_preferences'
+        '(--theme-dark)'--theme-dark='[set the color theme for syntax highlighting for dark backgrounds]:theme:->themes'
+        '(--theme-light)'--theme-light='[set the color theme for syntax highlighting for light backgrounds]:theme:->themes'
+        '(: --list-themes --list-languages -L)'--list-themes'[show all supported highlighting themes]'
+        --style='[comma-separated list of style elements to display]: : _values "style [default]"
+            default auto full plain changes header header-filename header-filesize grid rule numbers snip'
+        \*{-r+,--line-range=}'[only print the specified line range]:start\:end'
+        '(* -)'{-L,--list-languages}'[display all supported languages]'
+        -P'[disable paging]'
+        "--no-config[don't use the configuration file]"
+        "--no-custom-assets[don't load custom assets]"
+        '(--no-lessopen)'--lessopen'[enable the $LESSOPEN preprocessor]'
+        '(--lessopen)'--no-lessopen'[disable the $LESSOPEN preprocessor if enabled (overrides --lessopen)]'
+        '(* -)'--config-dir"[show bat's configuration directory]"
+        '(* -)'--config-file'[show path to the configuration file]'
+        '(* -)'--generate-config-file'[generate a default configuration file]'
+        '(* -)'--cache-dir"[show bat's cache directory]"
+        '(* -)'{-h,--help}'[show help information]'
+        '(* -)'{-V,--version}'[show version information]'
+        '*: :{ _files || compadd cache }'
     )
 
-    _arguments -S -s $args
+    _arguments -S -s $args && ret=0
 
     case "$state" in
-        language)
+        syntax-maps)
+          if ! compset -P '*:'; then
+            _message -e patterns 'glob pattern:language'
+            return
+          fi
+        ;& # fall-through
+
+        languages)
             local IFS=$'\n'
             local -a languages
             languages=( $({{PROJECT_EXECUTABLE}} --list-languages | awk -F':|,' '{ for (i = 1; i <= NF; ++i) printf("%s:%s\n", $i, $1) }') )
 
-            _describe 'language' languages
+            _describe 'language' languages && ret=0
         ;;
 
-        theme)
-            local IFS=$'\n'
-            local -a themes
-            themes=( $({{PROJECT_EXECUTABLE}} --list-themes | sort) )
+        themes)
+            local -a themes expl
+            themes=(${(f)"$(_call_program themes {{PROJECT_EXECUTABLE}} --list-themes)"} )
 
-            _values 'theme' $themes
+            _wanted themes expl 'theme' compadd -a themes && ret=0
         ;;
+        theme_preferences)
+            local -a themes expl
+            themes=(auto dark light auto:always auto:system ${(f)"$(_call_program themes {{PROJECT_EXECUTABLE}} --list-themes)"} )
 
-        style)
-            _values -s , 'style' auto full plain changes header grid numbers snip
+            _wanted themes expl 'theme' compadd -a themes && ret=0
         ;;
     esac
+
+    return ret
 }
 
-# first positional argument
-if (( ${#words} == 2 )); then
-    local -a subcommands
-    subcommands=('cache:Modify the syntax-definition and theme cache')
-    _describe subcommand subcommands
-    _{{PROJECT_EXECUTABLE}}_main
-else
-    case $words[2] in
-        cache)
-            _{{PROJECT_EXECUTABLE}}_cache_subcommand
-        ;;
+case $words[2] in
+    cache)
+        ## Completion of the 'cache' command itself is removed for better UX
+        ## See https://github.com/sharkdp/bat/issues/2085#issuecomment-1271646802
+        shift words
+        (( CURRENT-- ))
+        curcontext="${curcontext%:*}-${words[1]}:"
+        _{{PROJECT_EXECUTABLE}}_cache_subcommand
+    ;;
 
-        *)
-            _{{PROJECT_EXECUTABLE}}_main
-        ;;
-    esac
-fi
+    *)
+        _{{PROJECT_EXECUTABLE}}_main
+    ;;
+esac

assets/create.sh

@@ -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
+    )
+}
 
-(
-    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
+trap reverse_patches EXIT
+
+bat cache --build --blank --acknowledgements --source="$ASSET_DIR" --target="$ASSET_DIR"

assets/manual/bat.1.in

@@ -25,11 +25,40 @@ 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\-\-binary\fR <behavior>
+.IP
+How to treat binary content.
+
+Possible values:
+.RS
+.IP "no\-printing"
+Do not print any binary content (default)
+.IP "as\-text"
+Treat binary content as normal text
+.RE
+.HP
+\fB\-\-completion\fR <SHELL>
+.IP
+Show shell completion for a certain shell.
+Possible values: bash, fish, zsh, ps1
+.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
@@ -50,6 +79,8 @@ 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>...
@@ -73,6 +104,10 @@ Set the tab width to T spaces. Use a width of 0 to pass tabs through directly
 Specify the text\-wrapping mode (*auto*, never, character). The '\-\-terminal\-width' option
 can be used in addition to control the output width.
 .HP
+\fB\-S\fR, \fB\-\-chop\-long\-lines\fR
+.IP
+Truncate all lines longer than screen width. Alias for '\-\-wrap=never'.
+.HP
 \fB\-\-terminal\-width\fR <width>
 .IP
 Explicitly set the width of the terminal instead of determining it automatically. If
@@ -116,6 +151,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
@@ -125,24 +162,83 @@ use -m '*.build:Python'. To highlight files named '.myignore' with the Git Ignor
 syntax, use -m '.myignore:Git Ignore'.
 Note that the right-hand side is the *name* of the syntax, not a file extension.
 .HP
+\fB\-\-ignored\-suffix\fR <ignored-suffix>
+.IP
+Ignore extension. For example: 'bat \-\-ignored-suffix ".dev" my_file.json.dev'
+will use JSON syntax, and ignore '.dev'
+.HP
 \fB\-\-theme\fR <theme>
 .IP
-Set the theme for syntax highlighting. Use '\-\-list\-themes' to see all available themes.
-To set a default theme, add the '\-\-theme="..."' option to the configuration file or
-export the BAT_THEME environment variable (e.g.: export BAT_THEME="...").
+Set the theme for syntax highlighting. Use \fB\-\-list\-themes\fP to see all available themes.
+To set a default theme, add the \fB\-\-theme="..."\fP option to the configuration file or
+export the \fBBAT_THEME\fP environment variable (e.g.: \fBexport BAT_THEME="..."\fP).
+
+Special values:
+.RS
+.IP "auto (\fIdefault\fR)"
+Picks a dark or light theme depending on the terminal's colors.
+Use \fB-\-theme\-light\fR and \fB-\-theme\-dark\fR to customize the selected theme.
+.IP "auto:always"
+Variation of \fBauto\fR where where the terminal's colors are detected even when the output is redirected.
+.IP "auto:system (macOS only)"
+Variation of \fBauto\fR where the color scheme is detected from the system-wide preference instead.
+.IP "dark"
+Use the dark theme specified by \fB-\-theme-dark\fR.
+.IP "light"
+Use the light theme specified by \fB-\-theme-light\fR.
+.RE
+.HP
+\fB\-\-theme\-dark\fR <theme>
+.IP
+Sets the theme name for syntax highlighting used when the terminal uses a dark background.
+To set a default theme, add the \fB\-\-theme-dark="..."\fP option to the configuration file or
+export the \fBBAT_THEME_DARK\fP environment variable (e.g. \fBexport BAT_THEME_DARK="..."\fP).
+This option only has an effect when \fB\-\-theme\fP option is set to \fBauto\fR or \fBdark\fR.
+.HP
+\fB\-\-theme\-light\fR <theme>
+.IP
+Sets the theme name for syntax highlighting used when the terminal uses a light background.
+To set a default theme, add the \fB\-\-theme-light="..."\fP option to the configuration file or
+export the \fBBAT_THEME_LIGHT\fP environment variable (e.g. \fBexport BAT_THEME_LIGHT="..."\fP).
+This option only has an effect when \fB\-\-theme\fP option is set to \fBauto\fR or \fBlight\fR.
 .HP
 \fB\-\-list\-themes\fR
 .IP
 Display a list of supported themes for syntax highlighting.
 .HP
+\fB\-s\fR, \fB\-\-squeeze\-blank\fR
+.IP
+Squeeze consecutive empty lines into a single empty line.
+.HP
+\fB\-\-squeeze\-limit\fR <squeeze-limit>
+.IP
+Set the maximum number of consecutive empty lines to be printed.
+.HP
+\fB\-\-strip\-ansi\fR <when>
+.IP
+Specify when to strip ANSI escape sequences from the input. The automatic mode will remove
+escape sequences unless the syntax highlighting language is plain text. Possible values:
+auto, always, *never*.
+.HP
 \fB\-\-style\fR <style\-components>
 .IP
 Configure which elements (line numbers, file headers, grid borders, Git modifications,
 \&..) to display in addition to the file contents. The argument is a comma\-separated list
 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: *full*, auto, plain, changes, header, grid, rule, numbers, snip.
+export the BAT_STYLE environment variable (e.g.: export BAT_STYLE="..").
+.IP
+When styles are specified in multiple places, the "nearest" set of styles take precedence.
+The command\-line arguments are the highest priority, followed by the BAT_STYLE environment
+variable, and then the configuration file. If any set of styles consists entirely of
+components prefixed with "+" or "\-", it will modify the previous set of styles instead of
+replacing them.
+.IP
+By default, the following components are enabled:
+changes, grid, header\-filename, numbers, snip
+.IP
+Possible 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
@@ -154,6 +250,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
@@ -165,6 +263,30 @@ Display a list of supported languages for syntax highlighting.
 This option exists for POSIX\-compliance reasons ('u' is for 'unbuffered'). The output is
 always unbuffered \- this option is simply ignored.
 .HP
+\fB\-\-no\-custom\-assets\fR
+.IP
+Do not load custom assets.
+.HP
+\fB\-\-config\-dir\fR
+.IP
+Show bat's configuration directory.
+.HP
+\fB\-\-cache\-dir\fR
+.IP
+Show bat's cache directory.
+.HP
+\fB\-\-diagnostic\fR
+.IP
+Show diagnostic information for bug reports.
+.HP
+\fB\-\-acknowledgements\fR
+.IP
+Show acknowledgements.
+.HP
+\fB\-\-set\-terminal\-title\fR
+.IP
+Sets terminal title to filenames when using a pager.
+.HP
 \fB\-h\fR, \fB\-\-help\fR
 .IP
 Print this help message.
@@ -193,6 +315,20 @@ location of the configuration file.
 To generate a default configuration file, call:
 
 \fB{{PROJECT_EXECUTABLE}} --generate-config-file\fR
+
+These are related options:
+.HP
+\fB\-\-config\-file\fR
+.IP
+Show path to the configuration file.
+.HP
+\fB\-\-generate-config\-file\fR
+.IP
+Generates a default configuration file.
+.HP
+\fB\-\-no\-config\fR
+.IP
+Do not use the configuration file.
 .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
@@ -224,6 +360,33 @@ If you ever want to remove the custom languages, you can clear the cache with `\
 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
+
+These are related options:
+.HP
+\fB\-\-lessopen\fR
+.IP
+Enable the $LESSOPEN preprocessor.
+.HP
+\fB\-\-no\-lessopen\fR
+.IP
+Disable the $LESSOPEN preprocessor if enabled (overrides --lessopen)
+.PP
+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:

assets/patches/1337.tmTheme.patch

@@ -0,0 +1,22 @@
+diff --git themes/1337-Scheme/1337.tmTheme themes/1337-Scheme/1337.tmTheme
+index fdff5bf..8cfc888 100644
+--- themes/1337-Scheme/1337.tmTheme
++++ themes/1337-Scheme/1337.tmTheme
+@@ -280,7 +280,7 @@ SOFTWARE.
+ 			<key>name</key>
+ 			<string>PHP Namespaces</string>
+ 			<key>scope</key>
+-			<string>support.other.namespace, entity.name.type.namespace</string>
++			<string>support.other.namespace, entity.name.type.namespace, entity.name</string>
+ 			<key>settings</key>
+ 			<dict>
+ 				<key>foreground</key>
+@@ -561,7 +561,7 @@ SOFTWARE.
+ 		    <key>name</key>
+ 		    <string>diff.header</string>
+ 		    <key>scope</key>
+-		    <string>meta.diff, meta.diff.header</string>
++		    <string>meta.diff, meta.diff.header, markup.heading</string>
+ 		    <key>settings</key>
+ 		    <dict>
+ 			<key>foreground</key>

assets/patches/JavaScript.sublime-syntax.patch

@@ -0,0 +1,14 @@
+Submodule assets/syntaxes/01_Packages contains modified content
+diff --git syntaxes/01_Packages/JavaScript/JavaScript.sublime-syntax syntaxes/01_Packages/JavaScript/JavaScript.sublime-syntax
+index 05a4fed6..78a7bf55 100644
+--- syntaxes/01_Packages/JavaScript/JavaScript.sublime-syntax
++++ syntaxes/01_Packages/JavaScript/JavaScript.sublime-syntax
+@@ -5,7 +5,7 @@ name: JavaScript
+ file_extensions:
+   - js
+   - htc
+-first_line_match: ^#!\s*/.*\b(node|js)\b
++first_line_match: ^#!\s*/.*\b(node|bun|js)\b
+ scope: source.js
+ variables:
+   bin_digit: '[01_]'

assets/patches/Markdown.sublime-syntax.patch

@@ -1,5 +1,5 @@
 diff --git syntaxes/01_Packages/Markdown/Markdown.sublime-syntax syntaxes/01_Packages/Markdown/Markdown.sublime-syntax
-index 19dc685d..44440c7f 100644
+index 19dc685d..3a45ea05 100644
 --- syntaxes/01_Packages/Markdown/Markdown.sublime-syntax
 +++ syntaxes/01_Packages/Markdown/Markdown.sublime-syntax
 @@ -24,7 +24,6 @@ variables:
@@ -166,7 +166,29 @@ index 19dc685d..44440c7f 100644
      - match: ^\s*$\n?
        scope: invalid.illegal.non-terminated.bold-italic.markdown
        pop: true
-@@ -1152,7 +1110,7 @@ contexts:
+@@ -1073,6 +1031,21 @@ contexts:
+       escape: '{{code_fence_escape}}'
+       escape_captures:
+         0: meta.code-fence.definition.end.python.markdown-gfm
++        1: punctuation.definition.raw.code-fence.end.markdown
++    - match: |-
++         (?x)
++          {{fenced_code_block_start}}
++          ((?i:puppet))
++          {{fenced_code_block_trailing_infostring_characters}}
++      captures:
++        0: meta.code-fence.definition.begin.puppet.markdown-gfm
++        2: punctuation.definition.raw.code-fence.begin.markdown
++        5: constant.other.language-name.markdown
++      embed: scope:source.puppet
++      embed_scope: markup.raw.code-fence.puppet.markdown-gfm
++      escape: '{{code_fence_escape}}'
++      escape_captures:
++        0: meta.code-fence.definition.end.puppet.markdown-gfm
+         1: punctuation.definition.raw.code-fence.end.markdown
+     - match: |-
+          (?x)
+@@ -1152,7 +1125,7 @@ contexts:
      - match: |-
           (?x)
            {{fenced_code_block_start}}

assets/patches/MediaWiki.sublime-syntax.patch

@@ -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
+ 

assets/patches/Monokai-Extended.tmTheme.patch

@@ -21,11 +21,26 @@ index 9c2aa3e..180cbbf 100644
        <string>Invalid</string>
        <key>scope</key>
 -      <string>invalid</string>
-+      <string>invalid, markup.error</string>
++      <string>invalid, meta.annotation.error-line</string>
        <key>settings</key>
        <dict>
          <key>background</key>
-@@ -1042,7 +1042,7 @@
+@@ -1038,11 +1038,22 @@
+         <string>#f8f8f0</string>
+       </dict>
+     </dict>
++    <dict>
++      <key>name</key>
++      <string>Error</string>
++      <key>scope</key>
++      <string>markup.error</string>
++      <key>settings</key>
++      <dict>
++        <key>foreground</key>
++        <string>#dd2020</string>
++      </dict>
++    </dict>
+     <dict>
        <key>name</key>
        <string>Invalid deprecated</string>
        <key>scope</key>

assets/patches/OneHalfDark.tmTheme.patch

@@ -0,0 +1,47 @@
+diff --git themes/onehalf/sublimetext/OneHalfDark.tmTheme themes/onehalf/sublimetext/OneHalfDark.tmTheme
+index b16050c..b021071 100644
+--- themes/onehalf/sublimetext/OneHalfDark.tmTheme
++++ themes/onehalf/sublimetext/OneHalfDark.tmTheme
+@@ -28,7 +28,7 @@
+ <plist version="1.0">
+ <dict>
+ 	<key>name</key>
+-	<string>OneHalfLight</string>
++	<string>OneHalfDark</string>
+ 	<key>semanticClass</key>
+ 	<string>theme.dark.one_half_dark</string>
+ 	<key>uuid</key>
+@@ -155,7 +155,7 @@
+ 			<key>name</key>
+ 			<string>Classes</string>
+ 			<key>scope</key>
+-			<string>support.class, entity.name.class, entity.name.type.class</string>
++			<string>support.class, entity.name.class, entity.name.type.class, entity.name</string>
+ 			<key>settings</key>
+ 			<dict>
+ 				<key>foreground</key>
+@@ -188,7 +188,7 @@
+ 			<key>name</key>
+ 			<string>Storage</string>
+ 			<key>scope</key>
+-			<string>storage</string>
++			<string>storage, meta.mapping.key string</string>
+ 			<key>settings</key>
+ 			<dict>
+ 				<key>foreground</key>
+@@ -309,7 +309,7 @@
+ 			<key>name</key>
+ 			<string>Markdown: Headings</string>
+ 			<key>scope</key>
+-			<string>markup.heading punctuation.definition.heading, entity.name.section</string>
++			<string>markup.heading punctuation.definition.heading, entity.name.section, markup.heading - text.html.markdown</string>
+ 			<key>settings</key>
+ 			<dict>
+ 				<key>fontStyle</key>
+@@ -660,4 +660,4 @@
+ 		</dict>
+ 	</array>
+ </dict>
+-</plist>
+\ No newline at end of file
++</plist>

assets/patches/TodoTxt.sublime-syntax.patch

@@ -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.

assets/patches/TwoDark.tmTheme.patch

@@ -0,0 +1,38 @@
+diff --git themes/TwoDark/TwoDark.tmTheme themes/TwoDark/TwoDark.tmTheme
+index 87fd358..56376d3 100644
+--- themes/TwoDark/TwoDark.tmTheme
++++ themes/TwoDark/TwoDark.tmTheme
+@@ -125,7 +125,7 @@
+ 			<key>name</key>
+ 			<string>Classes</string>
+ 			<key>scope</key>
+-			<string>support.class, entity.name.class, entity.name.type.class</string>
++			<string>support.class, entity.name.class, entity.name.type.class, entity.name</string>
+ 			<key>settings</key>
+ 			<dict>
+ 				<key>foreground</key>
+@@ -290,7 +290,7 @@
+ 			<key>name</key>
+ 			<string>Headings</string>
+ 			<key>scope</key>
+-			<string>markup.heading punctuation.definition.heading, entity.name.section</string>
++			<string>markup.heading punctuation.definition.heading, entity.name.section, markup.heading - text.html.markdown</string>
+ 			<key>settings</key>
+ 			<dict>
+ 				<key>fontStyle</key>
+@@ -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>

assets/syntaxes/02_Extra/Assembly (x86_64).sublime-syntax

@@ -1,5 +1,6 @@
 %YAML 1.2
 ---
+name: x86_64 Assembly
 file_extensions: [yasm, nasm, asm, inc, mac]
 scope: source.asm.x86_64
 
@@ -1364,4 +1365,3 @@ contexts:
       scope: invalid.keyword.operator.word.mnemonic.sse5.packed-arithmetic
     - match: '(?i)\b(pcmov|permp[ds]|pperm|prot[bdqw]|psh[al][bdqw])\b'
       scope: invalid.keyword.operator.word.mnemonic.sse5.simd-integer
-...

assets/syntaxes/02_Extra/CSV/CSV-comma.sublime-syntax

@@ -2,20 +2,21 @@
 ---
 # See http://www.sublimetext.com/docs/3/syntax.html
 name: Comma Separated Values
-file_extensions:
-  - csv
-  - tsv
-scope: text.csv
+scope: text.csv.comma
 variables:
-  field_separator: (?:[,;\t])
+  field_separator: (?:,)
   record_separator: (?:$\n?)
 contexts:
-  prototype:
-    - match: (?={{record_separator}})
-      pop: true
+  main:
+    - match: '^'
+      push: fields
+
   fields:
+    - include: record_separator
     - match: ''
       push:
+        - field_or_record_separator
+        - field5
         - field_or_record_separator
         - field4
         - field_or_record_separator
@@ -24,16 +25,20 @@ contexts:
         - field2
         - field_or_record_separator
         - field1
-  main:
-    - meta_include_prototype: false
-    - match: '^'
-      set: fields
 
-  field_or_record_separator:
+  record_separator_pop:
+    - match: (?={{record_separator}})
+      pop: true
+
+  record_separator:
     - meta_include_prototype: false
     - match: '{{record_separator}}'
       scope: punctuation.terminator.record.csv
       pop: true
+
+  field_or_record_separator:
+    - meta_include_prototype: false
+    - include: record_separator_pop
     - match: '{{field_separator}}'
       scope: punctuation.separator.sequence.csv
       pop: true
@@ -41,24 +46,16 @@ contexts:
   field_contents:
     - match: '"'
       scope: punctuation.definition.string.begin.csv
-      push: double_quoted_string
+      push: scope:text.csv#double_quoted_string
 
-    - match: (?={{field_separator}}|{{record_separator}})
-      pop: true
-
-  double_quoted_string:
-    - meta_include_prototype: false
-    - meta_scope: string.quoted.double.csv
-    - match: '""'
-      scope: constant.character.escape.csv
-    - match: '"'
-      scope: punctuation.definition.string.end.csv
+    - include: record_separator_pop
+    - match: (?={{field_separator}})
       pop: true
 
   field1:
     - match: ''
       set:
-        - meta_content_scope: meta.field-1.csv support.type
+        - meta_content_scope: meta.field-1.csv variable.parameter
         - include: field_contents
   field2:
     - match: ''
@@ -75,4 +72,8 @@ contexts:
       set:
         - meta_content_scope: meta.field-4.csv keyword.operator
         - include: field_contents
-
+  field5:
+    - match: ''
+      set:
+        - meta_content_scope: meta.field-5.csv string.unquoted
+        - include: field_contents

assets/syntaxes/02_Extra/CSV/CSV-pipe.sublime-syntax

@@ -0,0 +1,80 @@
+%YAML 1.2
+---
+# See http://www.sublimetext.com/docs/3/syntax.html
+name: Pipe Separated Values
+scope: text.csv.pipe
+variables:
+  field_separator: (?:\|)
+  record_separator: (?:$\n?)
+
+contexts:
+  main:
+    - match: '^'
+      push: fields
+
+  fields:
+    - include: record_separator
+    - match: ''
+      push:
+        - field_or_record_separator
+        - field5
+        - field_or_record_separator
+        - field4
+        - field_or_record_separator
+        - field3
+        - field_or_record_separator
+        - field2
+        - field_or_record_separator
+        - field1
+
+  record_separator_pop:
+    - match: (?={{record_separator}})
+      pop: true
+
+  record_separator:
+    - meta_include_prototype: false
+    - match: '{{record_separator}}'
+      scope: punctuation.terminator.record.csv
+      pop: true
+
+  field_or_record_separator:
+    - meta_include_prototype: false
+    - include: record_separator_pop
+    - match: '{{field_separator}}'
+      scope: punctuation.separator.sequence.csv
+      pop: true
+
+  field_contents:
+    - match: '"'
+      scope: punctuation.definition.string.begin.csv
+      push: scope:text.csv#double_quoted_string
+
+    - include: record_separator_pop
+    - match: (?={{field_separator}})
+      pop: true
+
+  field1:
+    - match: ''
+      set:
+        - meta_content_scope: meta.field-1.csv variable.parameter
+        - include: field_contents
+  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
+  field5:
+    - match: ''
+      set:
+        - meta_content_scope: meta.field-5.csv string.unquoted
+        - include: field_contents

assets/syntaxes/02_Extra/CSV/CSV-semi-colon.sublime-syntax

@@ -0,0 +1,79 @@
+%YAML 1.2
+---
+# See http://www.sublimetext.com/docs/3/syntax.html
+name: Semi-Colon Separated Values
+scope: text.csv.semi-colon
+variables:
+  field_separator: (?:;)
+  record_separator: (?:$\n?)
+contexts:
+  main:
+    - match: '^'
+      push: fields
+
+  fields:
+    - include: record_separator
+    - match: ''
+      push:
+        - field_or_record_separator
+        - field5
+        - field_or_record_separator
+        - field4
+        - field_or_record_separator
+        - field3
+        - field_or_record_separator
+        - field2
+        - field_or_record_separator
+        - field1
+
+  record_separator_pop:
+    - match: (?={{record_separator}})
+      pop: true
+
+  record_separator:
+    - meta_include_prototype: false
+    - match: '{{record_separator}}'
+      scope: punctuation.terminator.record.csv
+      pop: true
+
+  field_or_record_separator:
+    - meta_include_prototype: false
+    - include: record_separator_pop
+    - match: '{{field_separator}}'
+      scope: punctuation.separator.sequence.csv
+      pop: true
+
+  field_contents:
+    - match: '"'
+      scope: punctuation.definition.string.begin.csv
+      push: scope:text.csv#double_quoted_string
+
+    - include: record_separator_pop
+    - match: (?={{field_separator}})
+      pop: true
+
+  field1:
+    - match: ''
+      set:
+        - meta_content_scope: meta.field-1.csv variable.parameter
+        - include: field_contents
+  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
+  field5:
+    - match: ''
+      set:
+        - meta_content_scope: meta.field-5.csv string.unquoted
+        - include: field_contents

assets/syntaxes/02_Extra/CSV/CSV.sublime-syntax

@@ -0,0 +1,113 @@
+%YAML 1.2
+---
+# See http://www.sublimetext.com/docs/3/syntax.html
+name: Separated Values
+file_extensions:
+  - csv
+scope: text.csv
+variables:
+  field_separator_chars: ',;\t|'
+  field_separator: (?:[{{field_separator_chars}}])
+  record_separator: (?:$\n?)
+contexts:
+  main:
+    - meta_include_prototype: false
+    - include: three_field_separators
+    - include: single_separator_type_on_line
+    - match: '^'
+      push: unknown-separated-main
+
+  three_field_separators:
+    - match: ^(?=(?:[^,]*,){3})
+      set: scope:text.csv.comma
+    - match: ^(?=(?:[^;]*;){3})
+      set: scope:text.csv.semi-colon
+    - match: ^(?=(?:[^\t]*\t){3})
+      set: scope:text.csv.tab
+    - match: ^(?=(?:[^|]*\|){3})
+      set: scope:text.csv.pipe
+
+  single_separator_type_on_line:
+    - match: ^(?=[^{{field_separator_chars}}]*,[^;\t|]*$)
+      set: scope:text.csv.comma
+    - match: ^(?=[^{{field_separator_chars}}]*;[^,\t|]*$)
+      set: scope:text.csv.semi-colon
+    - match: ^(?=[^{{field_separator_chars}}]*\t[^,;|]*$)
+      set: scope:text.csv.tab
+    - match: ^(?=[^{{field_separator_chars}}]*\|[^,;\t]*$)
+      set: scope:text.csv.pipe
+
+  unknown-separated-main:
+    - include: record_separator
+    - match: ''
+      push:
+        - field_or_record_separator
+        - field5
+        - field_or_record_separator
+        - field4
+        - field_or_record_separator
+        - field3
+        - field_or_record_separator
+        - field2
+        - field_or_record_separator
+        - field1
+
+  record_separator_pop:
+    - match: (?={{record_separator}})
+      pop: true
+
+  record_separator:
+    - meta_include_prototype: false
+    - match: '{{record_separator}}'
+      scope: punctuation.terminator.record.csv
+
+  field_or_record_separator:
+    - meta_include_prototype: false
+    - include: record_separator_pop
+    - match: '{{field_separator}}'
+      scope: punctuation.separator.sequence.csv
+      pop: true
+
+  field_contents:
+    - match: '"'
+      scope: punctuation.definition.string.begin.csv
+      push: double_quoted_string
+
+    - include: record_separator_pop
+    - match: (?={{field_separator}})
+      pop: true
+
+  double_quoted_string:
+    - meta_include_prototype: false
+    - meta_scope: string.quoted.double.csv
+    - match: '""'
+      scope: constant.character.escape.csv
+    - match: '"'
+      scope: punctuation.definition.string.end.csv
+      pop: true
+
+  field1:
+    - match: ''
+      set:
+        - meta_content_scope: meta.field-1.csv variable.parameter
+        - include: field_contents
+  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
+  field5:
+    - match: ''
+      set:
+        - meta_content_scope: meta.field-5.csv string.unquoted
+        - include: field_contents

assets/syntaxes/02_Extra/CSV/TSV.sublime-syntax

@@ -0,0 +1,83 @@
+%YAML 1.2
+---
+# See http://www.sublimetext.com/docs/3/syntax.html
+name: Tab Separated Values
+scope: text.csv.tab
+file_extensions:
+  - tsv
+
+variables:
+  field_separator: (?:\t)
+  record_separator: (?:$\n?)
+
+contexts:
+  main:
+    - match: '^'
+      push: fields
+
+  fields:
+    - include: record_separator
+    - match: ''
+      push:
+        - field_or_record_separator
+        - field5
+        - field_or_record_separator
+        - field4
+        - field_or_record_separator
+        - field3
+        - field_or_record_separator
+        - field2
+        - field_or_record_separator
+        - field1
+
+  record_separator_pop:
+    - match: (?={{record_separator}})
+      pop: true
+
+  record_separator:
+    - meta_include_prototype: false
+    - match: '{{record_separator}}'
+      scope: punctuation.terminator.record.csv
+      pop: true
+
+  field_or_record_separator:
+    - meta_include_prototype: false
+    - include: record_separator_pop
+    - match: '{{field_separator}}'
+      scope: punctuation.separator.sequence.csv
+      pop: true
+
+  field_contents:
+    - match: '"'
+      scope: punctuation.definition.string.begin.csv
+      push: scope:text.csv#double_quoted_string
+
+    - include: record_separator_pop
+    - match: (?={{field_separator}})
+      pop: true
+
+  field1:
+    - match: ''
+      set:
+        - meta_content_scope: meta.field-1.csv variable.parameter
+        - include: field_contents
+  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
+  field5:
+    - match: ''
+      set:
+        - meta_content_scope: meta.field-5.csv string.unquoted
+        - include: field_contents

assets/syntaxes/02_Extra/Dart.sublime-syntax

@@ -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_]+))'
-      captures:
-        1: annotation.dart
-        2: entity.name.function.annotation.dart
-        3: support.type.dart
+    - match: '@[a-zA-Z]+'
+      scope: storage.type.annotation.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
-    - match: (///)
-      captures:
-        1: marker.dart
+        - include: comments-block
+  comments-doc:
+    - match: ///
       push:
-        - meta_scope: comment.line.triple-slash.dart
-        - match: $
+        - meta_scope: comment.block.documentation.dart
+        - match: .*
           pop: true
-        - include: scope:text.dart-doccomments
-    - match: (//)
-      captures:
-        1: marker.dart
+        - include: dartdoc
+  comments-doc-oldschool:
+    - match: /\*\*
       push:
-        - meta_scope: comment.line.double-slash.dart
-        - match: $
+        - meta_scope: comment.block.documentation.dart
+        - 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: \bclass\b
+    - match: '(?<![a-zA-Z0-9_$])([_$]*[A-Z][a-zA-Z0-9_$]*|bool\b|num\b|int\b|double\b|dynamic\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
-        - match: "(?={)"
+        - meta_content_scope: variable.other.source.dart
+        - match: '```'
           pop: true
-        - include: keywords
-        - match: "[A-Za-z_][A-Za-z0-9_]*"
-          scope: class.name.dart
-  decl-enum:
-    - match: \benum\b
+    - match: (`.*?`)
       captures:
-        0: keyword.declaration.dart
-      push:
-        - 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
+        0: variable.other.source.dart
+    - match: (`.*?`)
       captures:
-        1: storage.type.primitive.dart
-        2: keyword.declaration.dart
-        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
+        0: variable.other.source.dart
+    - match: (\* ((    ).*))$
       captures:
-        1: type.user-defined.dart
-        2: keyword.declaration.dart
-        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
+        2: variable.other.source.dart
+    - match: (\*    .*)$
   keywords:
-    - match: \bassert\b
-      scope: keyword.control.assert.dart
-    - match: \bas\b
+    - 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+
-      scope: keyword.control.ternary.dart
-    - match: \b(break|case|continue|default|do|else|for|if|in|return|switch|while)\b
+    - 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
-      scope: keyword.control.async.dart
-    - match: \b(new)\b
+    - match: (?<!\$)\b(sync(\*)?|async(\*)?|await|yield(\*)?)\b(?!\$)
+      scope: keyword.control.dart
+    - 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
-    - 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
+      scope: punctuation.dot.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

assets/syntaxes/02_Extra/DotENV.sublime-syntax

@@ -8,6 +8,7 @@ file_extensions:
   - .env.local
   - .env.sample
   - .env.example
+  - .env.template
   - .env.test
   - .env.test.local
   - .env.testing
@@ -23,6 +24,10 @@ file_extensions:
   - .env.defaults
   - .envrc
   - .flaskenv
+  - env
+  - env.example
+  - env.sample
+  - env.template
 scope: source.env
 contexts:
   main:

assets/syntaxes/02_Extra/Fstab.sublime-syntax

@@ -95,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
@@ -107,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

assets/syntaxes/02_Extra/Hosts.sublime-syntax

@@ -1,23 +0,0 @@
-%YAML 1.2
----
-# http://www.sublimetext.com/docs/3/syntax.html
-name: hosts
-file_extensions:
-  - hosts
-scope: source.hosts
-
-contexts:
-  main:
-    - scope: comment.line.number-sign
-      match: \#.*
-      comment: comment
-
-    - match: ^\s*([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}|[0-9a-f:]+)
-      comment: ipaddress
-      scope: constant.numeric.ipaddress
-
-
-    - match: \s(localhost|ip6-loopback|ip6-localhost|ip6-localnet|ip6-mcastprefix|ip6-allnodes|ip6-allrouters|ip6-allhosts|broadcasthost)\b
-      scope: keyword.host.predefined}
-      comment: prefdfined
-

assets/syntaxes/02_Extra/INI.sublime-syntax

@@ -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

assets/syntaxes/02_Extra/Lean.sublime-syntax

@@ -1,125 +1,130 @@
 %YAML 1.2
 ---
-# http://www.sublimetext.com/docs/3/syntax.html
-name: Lean
+# http://www.sublimetext.com/docs/syntax.html
+name: Lean 4
 file_extensions:
   - lean
-scope: source.lean
+scope: source.lean4
 contexts:
   main:
     - include: comments
-    - match: '\b(?<!\.)(inductive|coinductive|structure|theorem|axiom|axioms|abbreviation|lemma|definition|def|instance|class|constant)\b\s+(\{[^}]*\})?'
+    - match: \b(Prop|Type|Sort)\b
+      scope: storage.type.lean4
+    - match: '\battribute\b\s*\[[^\]]*\]'
+      scope: storage.modifier.lean4
+    - match: '@\[[^\]]*\]'
+      scope: storage.modifier.lean4
+    - match: \b(?<!\.)(global|local|scoped|partial|unsafe|private|protected|noncomputable)(?!\.)\b
+      scope: storage.modifier.lean4
+    - match: \b(sorry|admit|stop)\b
+      scope: invalid.illegal.lean4
+    - match: '#(print|eval|reduce|check|check_failure)\b'
+      scope: keyword.other.lean4
+    - match: \bderiving\s+instance\b
+      scope: keyword.other.command.lean4
+    - match: '\b(?<!\.)(inductive|coinductive|structure|theorem|axiom|abbrev|lemma|def|instance|class|constant)\b\s+(\{[^}]*\})?'
       captures:
-        1: keyword.other.definitioncommand.lean
+        1: keyword.other.definitioncommand.lean4
       push:
-        - meta_scope: meta.definitioncommand.lean
-        - match: '(?=\bwith\b|\bextends\b|[:\|\(\[\{⦃<>])'
+        - meta_scope: meta.definitioncommand.lean4
+        - match: '(?=\bwith\b|\bextends\b|\bwhere\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: ','
+    - match: \b(?<!\.)(theorem|show|have|from|suffices|nomatch|def|class|structure|instance|set_option|initialize|builtin_initialize|example|inductive|coinductive|axiom|constant|universe|universes|variable|variables|import|open|export|theory|prelude|renaming|hiding|exposing|do|by|let|extends|mutual|mut|where|rec|syntax|macro_rules|macro|deriving|fun|section|namespace|end|infix|infixl|infixr|postfix|prefix|notation|abbrev|if|then|else|calc|match|with|for|in|unless|try|catch|finally|return|continue|break)(?!\.)\b
+      scope: keyword.other.lean4
     - match: «
       push:
-        - meta_content_scope: entity.name.lean
+        - meta_content_scope: entity.name.lean4
         - match: »
           pop: true
-    - match: \b(?<!\.)(if|then|else)\b
-      scope: keyword.control.lean
-    - match: '"'
+    - match: (s!)"
       captures:
-        0: punctuation.definition.string.begin.lean
+        1: keyword.other.lean4
       push:
-        - meta_scope: string.quoted.double.lean
+        - meta_scope: string.interpolated.lean4
         - match: '"'
-          captures:
-            0: punctuation.definition.string.end.lean
           pop: true
-        - match: '\\[\\"nt'']'
-          scope: constant.character.escape.lean
+        - match: '(\{)'
+          captures:
+            1: keyword.other.lean4
+          push:
+            - match: '(\})'
+              captures:
+                1: keyword.other.lean4
+              pop: true
+            - include: main
+        - match: '\\[\\"ntr'']'
+          scope: constant.character.escape.lean4
         - match: '\\x[0-9A-Fa-f][0-9A-Fa-f]'
-          scope: constant.character.escape.lean
+          scope: constant.character.escape.lean4
         - match: '\\u[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]'
-          scope: constant.character.escape.lean
+          scope: constant.character.escape.lean4
+    - match: '"'
+      push:
+        - meta_scope: string.quoted.double.lean4
+        - match: '"'
+          pop: true
+        - match: '\\[\\"ntr'']'
+          scope: constant.character.escape.lean4
+        - match: '\\x[0-9A-Fa-f][0-9A-Fa-f]'
+          scope: constant.character.escape.lean4
+        - match: '\\u[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]'
+          scope: constant.character.escape.lean4
+    - match: \b(true|false)\b
+      scope: constant.language.lean4
     - match: '''[^\\'']'''
-      scope: string.quoted.single.lean
-    - match: '''(\\(x..|u....|.))'''
-      scope: string.quoted.single.lean
+      scope: string.quoted.single.lean4
+    - match: '''(\\(x[0-9A-Fa-f][0-9A-Fa-f]|u[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]|.))'''
+      scope: string.quoted.single.lean4
       captures:
-        1: constant.character.escape.lean
+        1: constant.character.escape.lean4
     - match: '`+[^\[(]\S+'
-      scope: entity.name.lean
-    - match: '\b([0-9]+|0([xX][0-9a-fA-F]+))\b'
-      scope: constant.numeric.lean
+      scope: entity.name.lean4
+    - match: '\b([0-9]+|0([xX][0-9a-fA-F]+)|[-]?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?)\b'
+      scope: constant.numeric.lean4
   blockComment:
     - match: /-
       push:
-        - meta_scope: comment.block.lean
-        - match: "-/"
+        - meta_scope: comment.block.lean4
+        - match: '-/'
           pop: true
-        - include: scope:source.lean.markdown
+        - include: scope:source.lean4.markdown
         - include: blockComment
   comments:
     - include: dashComment
     - include: docComment
-    - include: stringBlock
     - include: modDocComment
     - include: blockComment
   dashComment:
-    - match: (--)
-      captures:
-        0: punctuation.definition.comment.lean
+    - match: '--'
       push:
-        - meta_scope: comment.line.double-dash.lean
+        - meta_scope: comment.line.double-dash.lean4
         - match: $
           pop: true
-        - include: scope:source.lean.markdown
+        - include: scope:source.lean4.markdown
   definitionName:
     - match: '\b[^:«»\(\)\{\}[:space:]=→λ∀?][^:«»\(\)\{\}[:space:]]*'
-      scope: entity.name.function.lean
+      scope: entity.name.function.lean4
     - match: «
       push:
-        - meta_content_scope: entity.name.function.lean
+        - meta_content_scope: entity.name.function.lean4
         - match: »
           pop: true
   docComment:
     - match: /--
       push:
-        - meta_scope: comment.block.documentation.lean
-        - match: "-/"
+        - meta_scope: comment.block.documentation.lean4
+        - match: '-/'
           pop: true
-        - include: scope:source.lean.markdown
+        - include: scope:source.lean4.markdown
         - include: blockComment
   modDocComment:
     - match: /-!
       push:
-        - meta_scope: comment.block.documentation.lean
-        - match: "-/"
+        - meta_scope: comment.block.documentation.lean4
+        - 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: scope:source.lean4.markdown
         - include: blockComment

assets/syntaxes/02_Extra/LiveScript.sublime-syntax

@@ -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

assets/syntaxes/02_Extra/Manpage.sublime-syntax

@@ -53,6 +53,16 @@ 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
@@ -75,7 +85,10 @@ contexts:
 
   options:
     # command-line options like --option=value, --some-flag, or -x
-    - match: '^[ ]{7}(?=-)'
+    - match: '^[ ]{7}(-)(?=\s)'
+      captures:
+        1: entity.name.command-line-option.man
+    - match: '^[ ]{7}(?=-|\+)'
       push: expect-command-line-option
     - match: '(?:[^a-zA-Z0-9_-]|^|\s){{command_line_option}}'
       captures:
@@ -96,7 +109,7 @@ contexts:
     - 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:
@@ -122,7 +135,7 @@ contexts:
       pop: true
 
   expect-parameter:
-    - match: '[A-Za-z0-9-]+'
+    - match: '[A-Za-z0-9-_]+'
       scope: variable.parameter.man
     - match: (?=\s+\|)
       pop: true
@@ -135,6 +148,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
 
@@ -169,3 +186,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

assets/syntaxes/02_Extra/Nim.sublime-syntax

@@ -5,6 +5,7 @@ name: Nim
 file_extensions:
   - nim
   - nims
+  - nimble
 scope: source.nim
 contexts:
   main:

assets/syntaxes/02_Extra/PowerShell.sublime-syntax

@@ -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: "''"
-          scope: constant.character.escape.powershell
-    - match: \@"(?=$)
+    - match: '(@["\x{201C}-\x{201E}])\s*$'
+      captures:
+        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
-        2: punctuation.section.group.begin.powershell
+        1: keyword.other.substatement.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
-        2: punctuation.section.group.begin.powershell
+        1: keyword.other.substatement.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:

assets/syntaxes/02_Extra/Racket.sublime-syntax

@@ -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

assets/syntaxes/02_Extra/Requirementstxt.sublime-syntax

@@ -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

assets/syntaxes/02_Extra/Stylus.sublime-syntax

@@ -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
 

assets/syntaxes/02_Extra/TypeScript.sublime-syntax

@@ -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*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          (\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*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          (\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*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\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*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          (\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*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-              (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+              (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+              \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+              (\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*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\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*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-              (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+              (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+              \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+              (\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*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          (\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
-        4: storage.type.ts
+        3: storage.modifier.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
-        4: keyword.operator.new.ts
-        5: keyword.generator.asterisk.ts
+        3: storage.modifier.ts
+        4: storage.modifier.async.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
-        4: storage.type.property.ts
-        5: keyword.generator.asterisk.ts
+        3: storage.modifier.ts
+        4: storage.modifier.async.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: class-declaration
-        - include: type
+        - include: expression
   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*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          (\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*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          (\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*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\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*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          (\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*)?`)'
-      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
+    - include: template-call
     - 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*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          (\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*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\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*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          (\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*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          (\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*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\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*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\([^\(\)]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
-          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<[^<>]+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
+          (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?                                                                                 # typeparameters
+          \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\)   # parameters
+          (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)?                                                                        # return type
           \s*=>                                                                                               # arrow operator
         )
           ))

assets/syntaxes/02_Extra/VimHelp.sublime-syntax

@@ -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

assets/syntaxes/02_Extra/apt-source-list.sublime-syntax

@@ -0,0 +1,42 @@
+%YAML 1.2
+---
+# See http://www.sublimetext.com/docs/syntax.html
+name: debsources
+file_extensions:
+  - sources.list
+scope: text.apt-source-list
+contexts:
+  main:
+    - include: comments
+    - match: ^[\w-]+
+      scope: constant.language.apt-source-list
+    - match: \w+://\S+
+      scope: markup.underline.link.apt-source-list
+      push: distribution
+    - match: \bmain\b
+      scope: support.class.apt-source-list
+    - match: \buniverse\b
+      scope: support.constant.apt-source-list
+    - match: \brestricted\b
+      scope: storage.modifier.apt-source-list
+    - match: \bmultiverse\b
+      scope: keyword.other.apt-source-list
+    - match: '[\w-]+'
+      scope: constant.other.apt-source-list
+
+  comments:
+    - match: '#'
+      scope: punctuation.definition.comment.apt-source-list
+      push: line_comment
+
+  line_comment:
+    - meta_scope: comment.line.apt-source-list
+    - match: $
+      pop: true
+
+  distribution:
+    - match: \S+
+      scope: support.type.apt-source-list
+      pop: 1
+    - match: $
+      pop: 1

assets/syntaxes/02_Extra/log.sublime-syntax

@@ -6,8 +6,16 @@ file_extensions:
 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
@@ -17,31 +25,85 @@ contexts:
       captures:
         1: punctuation.definition.string.begin.log
         3: punctuation.definition.string.end.log
-    - match: (")([^"]*)(")
-      scope: string.quoted.double.log
+    - match: \"
       captures:
         1: punctuation.definition.string.begin.log
-        3: punctuation.definition.string.end.log
+      push: double_quoted_string
     - include: dates
     - include: ip_addresses
     - include: numbers
-    - match: \b(?i:fail(?:ure|ed)?|error|exception)\b
-      scope: markup.error.log
-    - match: \b(?i:warn(?:ing)?)\b
-      scope: markup.warning.log
+    - 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_meta
+        - main_pop_at_eol
+    - match: (?=.*{{warning}})
+      push:
+        - warning_line_meta
+        - main_pop_at_eol
+    - match: (?=.*{{info}})
+      push:
+        - info_line_meta
+        - main_pop_at_eol
+    - match: (?=.*{{debug}})
+      push:
+        - debug_line_meta
+        - 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:
+    - meta_scope: meta.annotation.error-line.log
+    - include: immediately_pop
+  warning_line_meta:
+    - meta_scope: meta.annotation.warning-line.log
+    - include: immediately_pop
+  info_line_meta:
+    - meta_scope: meta.annotation.info-line.log
+    - include: immediately_pop
+  debug_line_meta:
+    - 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
+    - match: \b\d{4}-\d{2}-\d{2}(?=\b|T)
       scope: meta.date.log meta.number.integer.decimal.log constant.numeric.value.log
-    - match: \b\d{4}/\d{2}/\d{2}\b
+      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
-    - match: \b(?:[01]\d|2[0-3]):(?:[0-5]\d):(?:[0-5]\d)(?:(\.)\d{3})?\b
+      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:
@@ -50,8 +112,7 @@ contexts:
           scope: constant.numeric.value.log
         - match: \.
           scope: punctuation.separator.sequence.log
-        - match: ''
-          pop: true
+        - 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
@@ -59,8 +120,7 @@ contexts:
           scope: constant.numeric.value.log
         - match: ':'
           scope: punctuation.separator.sequence.log
-        - match: ''
-          pop: true
+        - include: immediately_pop
   numbers:
     - match: \b(0x)(\h+)(?:(\.)(\h+))?\b
       scope: meta.number.float.hexadecimal.log
@@ -112,5 +172,13 @@ contexts:
       pop: true
     - match: '[^?!.,:*_~\s<&()%]+|\S'
       scope: markup.underline.link.path.log
-    - match: ''
+    - 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

assets/syntaxes/02_Extra/requirementstxt.sublime-syntax

@@ -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