48e799e...master · bat

git.iko.soy/bat

491 files changed+33315−4420

since splitsnapshots

unifiedsplit

.github/FUNDING.ymlnew file+1

@@ -0,0 +1 @@

1+github: [sharkdp, keith-hall, Enselic]

.github/ISSUE_TEMPLATE/bug_report.md+38−13

@@ -8,32 +8,57 @@ assignees: ''

88---

1010<!--

11−Hey there, thanks for creating an issue!

1211

13−In order to reproduce your issue, we might need to know a little bit more about the environment

14−which you're running `bat` on.

12+Hey there, thank you for reporting a bug!

1513

16−If you're on Linux or MacOS:

17− Please run the script at https://github.com/sharkdp/bat/blob/master/diagnostics/info.sh and

18− paste the output at the bottom of the bug report.

14+Please note that the following bugs have already been reported:

15+

16+* dpkg: error processing archive /some/path/some-program.deb (--unpack):

17+ trying to overwrite '/usr/.crates2.json'

18+

19+ See https://github.com/sharkdp/bat/issues/938

1920

20−If you're on Windows:

21− Please tell us about your Windows Version (e.g. "Windows 10 1908") at the

22− bottom of the bug report.

2321-->

2422

25−**What version of `bat` are you using?**

26−[paste the output of `bat --version` here]

23+**What steps will reproduce the bug?**

24+

25+1. step 1

26+2. step 2

27+3. ...

28+

29+**What happens?**

2730

28−**Describe the bug you encountered:**

2931...

3032

3133**What did you expect to happen instead?**

34+

3235...

3336

37+

3438**How did you install `bat`?**

39+

3540

3641

3742---

3843

39−[paste the output of `info.sh` here]

44+**bat version and environment**

45+

46+<!--

47+In order to reproduce your issue, please add some information about the environment

48+in which you're running bat. To do this, run the full `bat` command that demonstrates

49+the bug, and attach the `--diagnostic` option:

50+

51+ bat [other options and arguments…] --diagnostic

52+

53+Finally, paste the Markdown output here. Please make sure that it does not reveal any

54+personal information.

55+

56+

57+If you are running bat 0.17.1 or older (where --diagnostic is not available), please

58+run the script at

59+

60+ https://github.com/sharkdp/bat/blob/master/diagnostics/info.sh

61+

62+(click "Raw" to get the actual source code) and paste the Markdown output here. If you

63+are on Windows, please let us know your bat version and your Windows version.

64+-->

.github/ISSUE_TEMPLATE/config.yml−1

@@ -1,2 +1 @@

11blank_issues_enabled: true

2−

.github/ISSUE_TEMPLATE/feature_request.md−1

@@ -7,4 +7,3 @@ assignees: ''

88---

10−

.github/ISSUE_TEMPLATE/question.md+2−1

@@ -7,4 +7,5 @@ assignees: ''

88---

10−

10+<!-- Using a normal ticket is still fine, but feel free to ask your

11+questions about bat on https://github.com/sharkdp/bat/discussions instead. -->

.github/dependabot.ymlnew file+18

@@ -0,0 +1,18 @@

1+version: 2

2+updates:

3+- package-ecosystem: cargo

4+ directory: "/"

5+ schedule:

6+ interval: monthly

7+ time: "04:00"

8+ timezone: Europe/Berlin

9+ ignore:

10+ - dependency-name: git2

11+ versions:

12+ - 0.13.17

13+- package-ecosystem: gitsubmodule

14+ directory: "/"

15+ schedule:

16+ interval: monthly

17+ time: "04:00"

18+ timezone: Europe/Berlin

.github/workflows/CICD.yml+319−282

@@ -1,35 +1,69 @@

11name: CICD

33env:

4− PROJECT_NAME: bat

5− PROJECT_DESC: "A `cat` clone with wings"

6− PROJECT_MAINTAINER: "David Peter <mail@david-peter.de>"

7− PROJECT_HOMEPAGE: "https://github.com/sharkdp/bat"

8− MIN_SUPPORTED_RUST_VERSION: "1.40.0"

4+ MIN_SUPPORTED_RUST_VERSION: "1.51.0"

5+ CICD_INTERMEDIATES_DIR: "_cicd-intermediates"

10−on: [push, pull_request]

7+on:

8+ workflow_dispatch:

9+ pull_request:

10+ push:

11+ branches:

12+ - master

13+ tags:

14+ - '*'

1115

1216jobs:

17+ ensure_cargo_fmt:

18+ name: Ensure 'cargo fmt' has been run

19+ runs-on: ubuntu-20.04

20+ steps:

21+ - uses: actions-rs/toolchain@v1

22+ with:

23+ toolchain: stable

24+ default: true

25+ profile: minimal

26+ components: rustfmt

27+ - uses: actions/checkout@v2

28+ - run: cargo fmt -- --check

29+

30+ license_checks:

31+ name: License checks

32+ runs-on: ubuntu-20.04

33+ steps:

34+ - uses: actions/checkout@v2

35+ with:

36+ submodules: true # we especially want to perform license checks on submodules

37+ - run: tests/scripts/license-checks.sh

38+

1339 min_version:

1440 name: Minimum supported rust version

15− runs-on: ubuntu-latest

41+ runs-on: ubuntu-20.04

1642 steps:

17− - name: Git checkout

43+ - name: Checkout source code

1844 uses: actions/checkout@v2

45+

1946 - name: Install rust toolchain (v${{ env.MIN_SUPPORTED_RUST_VERSION }})

2047 uses: actions-rs/toolchain@v1

2148 with:

2249 toolchain: ${{ env.MIN_SUPPORTED_RUST_VERSION }}

2350 default: true

2451 profile: minimal # minimal component installation (ie, no documentation)

25− - name: Test

52+ components: clippy

53+ - name: Run clippy (on minimum supported rust version to prevent warnings we can't fix)

54+ uses: actions-rs/cargo@v1

55+ with:

56+ command: clippy

57+ args: --locked --all-targets --all-features

58+ - name: Run tests

2659 uses: actions-rs/cargo@v1

2760 with:

2861 command: test

62+ args: --locked

2963

3064 test_with_new_syntaxes_and_themes:

31− name: Test with new syntaxes and themes

32− runs-on: ubuntu-latest

65+ name: Run tests with updated syntaxes and themes

66+ runs-on: ubuntu-20.04

3367 steps:

3468 - name: Git checkout

3569 uses: actions/checkout@v2

@@ -57,166 +91,100 @@ jobs:

5791 uses: actions-rs/cargo@v1

5892 with:

5993 command: test

60− args: --release

94+ args: --locked --release

6195 - name: Run ignored-by-default unit tests with new syntaxes and themes

6296 uses: actions-rs/cargo@v1

6397 with:

6498 command: test

65− args: --release -- --ignored

99+ args: --locked --release -- --ignored

66100 - name: Syntax highlighting regression test

67101 run: tests/syntax-tests/regression_test.sh

68102 - name: List of languages

69103 run: bat --list-languages

70104 - name: List of themes

71105 run: bat --list-themes

106+ - name: Test custom assets

107+ run: tests/syntax-tests/test_custom_assets.sh

108+

109+ documentation:

110+ name: Documentation

111+ runs-on: ubuntu-20.04

112+ steps:

113+ - name: Git checkout

114+ uses: actions/checkout@v2

115+ - name: Install Rust toolchain

116+ uses: actions-rs/toolchain@v1

117+ with:

118+ toolchain: stable

119+ default: true

120+ profile: minimal

121+ - name: Print -h

122+ uses: actions-rs/cargo@v1

123+ with:

124+ command: run

125+ args: --locked -- -h

126+ - name: Print --help

127+ uses: actions-rs/cargo@v1

128+ with:

129+ command: run

130+ args: --locked -- --help

131+ - name: Show man page

132+ run: man $(find . -name bat.1)

133+ - name: Check documentation

134+ env:

135+ RUSTDOCFLAGS: -D warnings

136+ uses: actions-rs/cargo@v1

137+ with:

138+ command: doc

139+ args: --locked --no-deps --document-private-items --all-features

72140

73141 build:

74− name: Build

142+ name: ${{ matrix.job.target }} (${{ matrix.job.os }})

75143 runs-on: ${{ matrix.job.os }}

76144 strategy:

77145 fail-fast: false

78146 matrix:

79147 job:

80− # { os, target, cargo-options, features, use-cross, toolchain }

81− - { os: ubuntu-latest , target: arm-unknown-linux-gnueabihf , use-cross: use-cross }

82− - { os: ubuntu-18.04 , target: aarch64-unknown-linux-gnu , use-cross: use-cross }

83− - { os: ubuntu-18.04 , target: i686-unknown-linux-gnu , use-cross: use-cross }

84− - { os: ubuntu-18.04 , target: i686-unknown-linux-musl , use-cross: use-cross }

85− - { os: ubuntu-18.04 , target: x86_64-unknown-linux-gnu , use-cross: use-cross }

86− - { os: ubuntu-18.04 , target: x86_64-unknown-linux-musl , use-cross: use-cross }

87− - { os: ubuntu-16.04 , target: x86_64-unknown-linux-gnu , use-cross: use-cross }

88− - { os: macos-latest , target: x86_64-apple-darwin }

89− # - { os: windows-latest , target: i686-pc-windows-gnu } ## disabled; linker errors (missing '_imp____acrt_iob_func')

90− - { os: windows-latest , target: i686-pc-windows-msvc }

91− # - { os: windows-latest , target: x86_64-pc-windows-gnu } ## disabled; linker errors (missing '_imp____acrt_iob_func')

92− - { os: windows-latest , target: x86_64-pc-windows-msvc }

148+ - { target: aarch64-unknown-linux-gnu , os: ubuntu-20.04, use-cross: true }

149+ - { target: arm-unknown-linux-gnueabihf , os: ubuntu-20.04, use-cross: true }

150+ - { target: arm-unknown-linux-musleabihf, os: ubuntu-20.04, use-cross: true }

151+ - { target: i686-pc-windows-msvc , os: windows-2019 }

152+ - { target: i686-unknown-linux-gnu , os: ubuntu-20.04, use-cross: true }

153+ - { target: i686-unknown-linux-musl , os: ubuntu-20.04, use-cross: true }

154+ - { target: x86_64-apple-darwin , os: macos-10.15 }

155+ - { target: x86_64-pc-windows-gnu , os: windows-2019 }

156+ - { target: x86_64-pc-windows-msvc , os: windows-2019 }

157+ - { target: x86_64-unknown-linux-gnu , os: ubuntu-20.04, use-cross: true }

158+ - { target: x86_64-unknown-linux-musl , os: ubuntu-20.04, use-cross: true }

93159 steps:

94− - name: Git checkout

160+ - name: Checkout source code

95161 uses: actions/checkout@v2

162+

96163 - name: Install prerequisites

97164 shell: bash

98165 run: |

99166 case ${{ matrix.job.target }} in

100− arm-unknown-linux-gnueabihf) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;

167+ arm-unknown-linux-*) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;

101168 aarch64-unknown-linux-gnu) sudo apt-get -y update ; sudo apt-get -y install gcc-aarch64-linux-gnu ;;

102169 esac

103− - name: Initialize workflow variables

104− id: vars

105− shell: bash

106− run: |

107− # toolchain

108− TOOLCHAIN="stable" ## default to "stable" toolchain

109− # * specify alternate TOOLCHAIN for *-pc-windows-gnu targets; gnu targets on Windows are broken for the standard *-pc-windows-msvc toolchain (refs: <https://github.com/rust-lang/rust/issues/47048>, <https://github.com/rust-lang/rust/issues/53454>, <https://github.com/rust-lang/cargo/issues/6754>)

110− case ${{ matrix.job.target }} in *-pc-windows-gnu) TOOLCHAIN="stable-${{ matrix.job.target }}" ;; esac;

111− # * use requested TOOLCHAIN if specified

112− if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi

113− echo set-output name=TOOLCHAIN::${TOOLCHAIN}

114− echo ::set-output name=TOOLCHAIN::${TOOLCHAIN}

115− # staging directory

116− STAGING='_staging'

117− echo set-output name=STAGING::${STAGING}

118− echo ::set-output name=STAGING::${STAGING}

119− # determine EXE suffix

120− EXE_suffix="" ; case ${{ matrix.job.target }} in *-pc-windows-*) EXE_suffix=".exe" ;; esac;

121− echo set-output name=EXE_suffix::${EXE_suffix}

122− echo ::set-output name=EXE_suffix::${EXE_suffix}

123− # parse commit reference info

124− REF_NAME=${GITHUB_REF#refs/*/}

125− unset REF_BRANCH ; case ${GITHUB_REF} in refs/heads/*) REF_BRANCH=${GITHUB_REF#refs/heads/} ;; esac;

126− unset REF_TAG ; case ${GITHUB_REF} in refs/tags/*) REF_TAG=${GITHUB_REF#refs/tags/} ;; esac;

127− REF_SHAS=${GITHUB_SHA:0:8}

128− echo set-output name=REF_NAME::${REF_NAME}

129− echo set-output name=REF_BRANCH::${REF_BRANCH}

130− echo set-output name=REF_TAG::${REF_TAG}

131− echo set-output name=REF_SHAS::${REF_SHAS}

132− echo ::set-output name=REF_NAME::${REF_NAME}

133− echo ::set-output name=REF_BRANCH::${REF_BRANCH}

134− echo ::set-output name=REF_TAG::${REF_TAG}

135− echo ::set-output name=REF_SHAS::${REF_SHAS}

136− # parse target

137− unset TARGET_ARCH ; case ${{ matrix.job.target }} in arm-unknown-linux-gnueabihf) TARGET_ARCH=arm ;; i686-*) TARGET_ARCH=i686 ;; x86_64-*) TARGET_ARCH=x86_64 ;; esac;

138− echo set-output name=TARGET_ARCH::${TARGET_ARCH}

139− echo ::set-output name=TARGET_ARCH::${TARGET_ARCH}

140− unset TARGET_OS ; case ${{ matrix.job.target }} in *-linux-*) TARGET_OS=linux ;; *-apple-*) TARGET_OS=macos ;; *-windows-*) TARGET_OS=windows ;; esac;

141− echo set-output name=TARGET_OS::${TARGET_OS}

142− echo ::set-output name=TARGET_OS::${TARGET_OS}

143− # package name

144− PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;

145− PKG_BASENAME=${PROJECT_NAME}-${REF_TAG:-$REF_SHAS}-${{ matrix.job.target }}

146− PKG_NAME=${PKG_BASENAME}${PKG_suffix}

147− echo set-output name=PKG_suffix::${PKG_suffix}

148− echo set-output name=PKG_BASENAME::${PKG_BASENAME}

149− echo set-output name=PKG_NAME::${PKG_NAME}

150− echo ::set-output name=PKG_suffix::${PKG_suffix}

151− echo ::set-output name=PKG_BASENAME::${PKG_BASENAME}

152− echo ::set-output name=PKG_NAME::${PKG_NAME}

153− # deployable tag? (ie, leading "vM" or "M"; M == version number)

154− unset DEPLOY ; if [[ $REF_TAG =~ ^[vV]?[0-9].* ]]; then DEPLOY='true' ; fi

155− # unset deploy on ubuntu-18.04 x64 - we will deploy the tarball/deb built on ubuntu-16.04 x64

156− if [ "${{ matrix.job.os }}" = "ubuntu-18.04" ] && [ "${{ matrix.job.target }}" = "x86_64-unknown-linux-gnu" ]; then unset DEPLOY; fi

157− echo set-output name=DEPLOY::${DEPLOY:-<empty>/false}

158− echo ::set-output name=DEPLOY::${DEPLOY}

159− # DPKG architecture?

160− unset DPKG_ARCH

161− case ${{ matrix.job.target }} in

162− aarch64-*-linux-*) DPKG_ARCH=arm64 ;;

163− arm-*-linux-*hf) DPKG_ARCH=armhf ;;

164− i686-*-linux-*) DPKG_ARCH=i686 ;;

165− x86_64-*-linux-*) DPKG_ARCH=amd64 ;;

166− esac;

167− echo set-output name=DPKG_ARCH::${DPKG_ARCH}

168− echo ::set-output name=DPKG_ARCH::${DPKG_ARCH}

169− # DPKG version?

170− unset DPKG_VERSION ; if [[ $REF_TAG =~ ^[vV]?[0-9].* ]]; then DPKG_VERSION=${REF_TAG/#[vV]/} ; fi

171− echo set-output name=DPKG_VERSION::${DPKG_VERSION}

172− echo ::set-output name=DPKG_VERSION::${DPKG_VERSION}

173− # DPKG base name/conflicts?

174− DPKG_BASENAME=${PROJECT_NAME}

175− DPKG_CONFLICTS=${PROJECT_NAME}-musl

176− case ${{ matrix.job.target }} in *-musl) DPKG_BASENAME=${PROJECT_NAME}-musl ; DPKG_CONFLICTS=${PROJECT_NAME} ;; esac;

177− echo set-output name=DPKG_BASENAME::${DPKG_BASENAME}

178− echo set-output name=DPKG_CONFLICTS::${DPKG_CONFLICTS}

179− echo ::set-output name=DPKG_BASENAME::${DPKG_BASENAME}

180− echo ::set-output name=DPKG_CONFLICTS::${DPKG_CONFLICTS}

181− # DPKG name

182− unset DPKG_NAME;

183− if [[ -n $DPKG_ARCH && -n $DPKG_VERSION ]]; then DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb" ; fi

184− echo set-output name=DPKG_NAME::${DPKG_NAME}

185− echo ::set-output name=DPKG_NAME::${DPKG_NAME}

186− # target-specific options

187− # * CARGO_USE_CROSS (truthy)

188− CARGO_USE_CROSS='true' ; case '${{ matrix.job.use-cross }}' in ''|0|f|false|n|no) unset CARGO_USE_CROSS ;; esac;

189− echo set-output name=CARGO_USE_CROSS::${CARGO_USE_CROSS:-<empty>/false}

190− echo ::set-output name=CARGO_USE_CROSS::${CARGO_USE_CROSS}

191− # # * `arm` cannot be tested on ubuntu-* hosts (b/c testing is currently primarily done via comparison of target outputs with built-in outputs and the `arm` target is not executable on the host)

192− JOB_DO_TESTING="true"

193− case ${{ matrix.job.target }} in arm-*) unset JOB_DO_TESTING ;; esac;

194− echo set-output name=JOB_DO_TESTING::${JOB_DO_TESTING:-<empty>/false}

195− echo ::set-output name=JOB_DO_TESTING::${JOB_DO_TESTING}

196− # # * test only library unit tests and binary for arm-type targets

197− unset CARGO_TEST_OPTIONS

198− unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-* | aarch64-*) CARGO_TEST_OPTIONS="--lib --bin ${PROJECT_NAME}" ;; esac;

199− echo set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}

200− echo ::set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}

201− # * executable for `strip`?

202− STRIP="strip" ; case ${{ matrix.job.target }} in arm-unknown-linux-gnueabihf) STRIP="arm-linux-gnueabihf-strip" ;; aarch64-unknown-linux-gnu) STRIP="aarch64-linux-gnu-strip" ;; *-pc-windows-msvc) STRIP="" ;; esac;

203− echo set-output name=STRIP::${STRIP}

204− echo ::set-output name=STRIP::${STRIP}

205− - name: Create all needed build/work directories

170+

171+ - name: Extract crate information

206172 shell: bash

207173 run: |

208− mkdir -p '${{ steps.vars.outputs.STAGING }}'

209− mkdir -p '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}'

210− mkdir -p '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/autocomplete'

211− mkdir -p '${{ steps.vars.outputs.STAGING }}/dpkg'

174+ echo "PROJECT_NAME=$(sed -n 's/^name = "$.*$"/\1/p' Cargo.toml | head -n1)" >> $GITHUB_ENV

175+ echo "PROJECT_VERSION=$(sed -n 's/^version = "$.*$"/\1/p' Cargo.toml | head -n1)" >> $GITHUB_ENV

176+ echo "PROJECT_MAINTAINER=$(sed -n 's/^authors = \["$.*$"\]/\1/p' Cargo.toml)" >> $GITHUB_ENV

177+ echo "PROJECT_HOMEPAGE=$(sed -n 's/^homepage = "$.*$"/\1/p' Cargo.toml)" >> $GITHUB_ENV

178+

212179 - name: Install Rust toolchain

213180 uses: actions-rs/toolchain@v1

214181 with:

215− toolchain: ${{ steps.vars.outputs.TOOLCHAIN }}

182+ toolchain: stable

216183 target: ${{ matrix.job.target }}

217184 override: true

218185 profile: minimal # minimal component installation (ie, no documentation)

219− - name: Info

186+

187+ - name: Show version information (Rust, cargo, GCC)

220188 shell: bash

221189 run: |

222190 gcc --version || true

@@ -225,221 +193,290 @@ jobs:

225193 rustup default

226194 cargo -V

227195 rustc -V

196+

228197 - name: Build

229198 uses: actions-rs/cargo@v1

230199 with:

231− use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}

200+ use-cross: ${{ matrix.job.use-cross }}

232201 command: build

233− args: --release --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }}

234− - name: Test

202+ args: --locked --release --target=${{ matrix.job.target }}

203+

204+ - name: Strip debug information from executable

205+ id: strip

206+ shell: bash

207+ run: |

208+ # Figure out suffix of binary

209+ EXE_suffix=""

210+ case ${{ matrix.job.target }} in

211+ *-pc-windows-*) EXE_suffix=".exe" ;;

212+ esac;

213+

214+ # Figure out what strip tool to use if any

215+ STRIP="strip"

216+ case ${{ matrix.job.target }} in

217+ arm-unknown-linux-*) STRIP="arm-linux-gnueabihf-strip" ;;

218+ aarch64-unknown-linux-gnu) STRIP="aarch64-linux-gnu-strip" ;;

219+ *-pc-windows-msvc) STRIP="" ;;

220+ esac;

221+

222+ # Setup paths

223+ BIN_DIR="${{ env.CICD_INTERMEDIATES_DIR }}/stripped-release-bin/"

224+ mkdir -p "${BIN_DIR}"

225+ BIN_NAME="${{ env.PROJECT_NAME }}${EXE_suffix}"

226+ BIN_PATH="${BIN_DIR}/${BIN_NAME}"

227+

228+ # Copy the release build binary to the result location

229+ cp "target/${{ matrix.job.target }}/release/${BIN_NAME}" "${BIN_DIR}"

230+

231+ # Also strip if possible

232+ if [ -n "${STRIP}" ]; then

233+ "${STRIP}" "${BIN_PATH}"

234+ fi

235+

236+ # Let subsequent steps know where to find the (stripped) bin

237+ echo ::set-output name=BIN_PATH::${BIN_PATH}

238+ echo ::set-output name=BIN_NAME::${BIN_NAME}

239+

240+ - name: Set testing options

241+ id: test-options

242+ shell: bash

243+ run: |

244+ # test only library unit tests and binary for arm-type targets

245+ unset CARGO_TEST_OPTIONS

246+ unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-* | aarch64-*) CARGO_TEST_OPTIONS="--lib --bin ${PROJECT_NAME}" ;; esac;

247+ echo ::set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}

248+

249+ - name: Run tests

235250 uses: actions-rs/cargo@v1

236251 with:

237− use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}

252+ use-cross: ${{ matrix.job.use-cross }}

238253 command: test

239− args: --target=${{ matrix.job.target }} ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }}

240− - name: bat test run

254+ args: --locked --target=${{ matrix.job.target }} ${{ steps.test-options.outputs.CARGO_TEST_OPTIONS}}

255+

256+ - name: Run bat

241257 uses: actions-rs/cargo@v1

242258 with:

243− use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}

259+ use-cross: ${{ matrix.job.use-cross }}

244260 command: run

245− args: --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} -- --paging=never --color=always --theme=ansi-dark Cargo.toml src/config.rs

246− - name: Check features regex-onig

261+ args: --locked --target=${{ matrix.job.target }} -- --paging=never --color=always --theme=ansi Cargo.toml src/config.rs

262+

263+ - name: Show diagnostics (bat --diagnostic)

247264 uses: actions-rs/cargo@v1

248265 with:

249− use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}

266+ use-cross: ${{ matrix.job.use-cross }}

267+ command: run

268+ args: --locked --target=${{ matrix.job.target }} -- --paging=never --color=always --theme=ansi Cargo.toml src/config.rs --diagnostic

269+

270+ - name: "Feature check: regex-onig"

271+ uses: actions-rs/cargo@v1

272+ with:

273+ use-cross: ${{ matrix.job.use-cross }}

250274 command: check

251− args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig

252− - name: Check features regex-onig,git

275+ args: --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig

276+

277+ - name: "Feature check: regex-onig,git"

253278 uses: actions-rs/cargo@v1

254279 with:

255− use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}

280+ use-cross: ${{ matrix.job.use-cross }}

256281 command: check

257− args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git

258− - name: Check features regex-onig,paging

282+ args: --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git

283+

284+ - name: "Feature check: regex-onig,paging"

259285 uses: actions-rs/cargo@v1

260286 with:

261− use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}

287+ use-cross: ${{ matrix.job.use-cross }}

262288 command: check

263− args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,paging

264− - name: Check features regex-onig,git,paging

289+ args: --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,paging

290+

291+ - name: "Feature check: regex-onig,git,paging"

265292 uses: actions-rs/cargo@v1

266293 with:

267− use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}

294+ use-cross: ${{ matrix.job.use-cross }}

268295 command: check

269− args: --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git,paging

270− - name: Upload build artifacts

271− uses: actions/upload-artifact@master

296+ args: --locked --target=${{ matrix.job.target }} --verbose --lib --no-default-features --features regex-onig,git,paging

297+

298+ - name: "Feature check: minimal-application"

299+ uses: actions-rs/cargo@v1

272300 with:

273− name: ${{ env.PROJECT_NAME }}-${{ matrix.job.target }}

274− path: target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}

275− - name: Package

301+ use-cross: ${{ matrix.job.use-cross }}

302+ command: check

303+ args: --locked --target=${{ matrix.job.target }} --verbose --no-default-features --features minimal-application

304+

305+ - name: Create tarball

306+ id: package

276307 shell: bash

277308 run: |

278− ARCHIVE_DIR='${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/'

279− # Binary

280− cp 'target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' "$ARCHIVE_DIR"

309+ PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;

310+ PKG_BASENAME=${PROJECT_NAME}-v${PROJECT_VERSION}-${{ matrix.job.target }}

311+ PKG_NAME=${PKG_BASENAME}${PKG_suffix}

312+ echo ::set-output name=PKG_NAME::${PKG_NAME}

313+

314+ PKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/package"

315+ ARCHIVE_DIR="${PKG_STAGING}/${PKG_BASENAME}/"

316+ mkdir -p "${ARCHIVE_DIR}"

317+ mkdir -p "${ARCHIVE_DIR}/autocomplete"

281318

282− # `strip` binary (if needed)

283− if [ -n "${{ steps.vars.outputs.STRIP }}" ]; then "${{ steps.vars.outputs.STRIP }}" "$ARCHIVE_DIR/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}" ; fi

319+ # Binary

320+ cp "${{ steps.strip.outputs.BIN_PATH }}" "$ARCHIVE_DIR"

284321

285322 # Man page

286323 cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/manual/bat.1 "$ARCHIVE_DIR"

287324

288− # README and LICENSE files

289− cp "README.md" "LICENSE-MIT" "LICENSE-APACHE" "$ARCHIVE_DIR"

325+ # README, LICENSE and CHANGELOG files

326+ cp "README.md" "LICENSE-MIT" "LICENSE-APACHE" "CHANGELOG.md" "$ARCHIVE_DIR"

290327

291328 # Autocompletion files

329+ cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.bash "$ARCHIVE_DIR/autocomplete/${{ env.PROJECT_NAME }}.bash"

292330 cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.fish "$ARCHIVE_DIR/autocomplete/${{ env.PROJECT_NAME }}.fish"

331+ cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/_bat.ps1 "$ARCHIVE_DIR/autocomplete/_${{ env.PROJECT_NAME }}.ps1"

293332 cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.zsh "$ARCHIVE_DIR/autocomplete/${{ env.PROJECT_NAME }}.zsh"

294333

295334 # base compressed package

296− pushd '${{ steps.vars.outputs.STAGING }}/' >/dev/null

335+ pushd "${PKG_STAGING}/" >/dev/null

297336 case ${{ matrix.job.target }} in

298− *-pc-windows-*) 7z -y a '${{ steps.vars.outputs.PKG_NAME }}' '${{ steps.vars.outputs.PKG_BASENAME }}'/* | tail -2 ;;

299− *) tar czf '${{ steps.vars.outputs.PKG_NAME }}' '${{ steps.vars.outputs.PKG_BASENAME }}'/* ;;

337+ *-pc-windows-*) 7z -y a "${PKG_NAME}" "${PKG_BASENAME}"/* | tail -2 ;;

338+ *) tar czf "${PKG_NAME}" "${PKG_BASENAME}"/* ;;

300339 esac;

301340 popd >/dev/null

302341

303− # Debian package

304− if [ -n "${{ steps.vars.outputs.DPKG_NAME }}" ]; then

305− DPKG_DIR="${{ steps.vars.outputs.STAGING }}/dpkg"

342+ # Let subsequent steps know where to find the compressed package

343+ echo ::set-output name=PKG_PATH::"${PKG_STAGING}/${PKG_NAME}"

306344

307− # Binary

308− install -Dm755 'target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' "${DPKG_DIR}/usr/bin/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}"

309− if [ -n "${{ steps.vars.outputs.STRIP }}" ]; then "${{ steps.vars.outputs.STRIP }}" "${DPKG_DIR}/usr/bin/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}" ; fi

345+ - name: Create Debian package

346+ id: debian-package

347+ shell: bash

348+ if: startsWith(matrix.job.os, 'ubuntu')

349+ run: |

350+ COPYRIGHT_YEARS="2018 - "$(date "+%Y")

351+ DPKG_STAGING="${{ env.CICD_INTERMEDIATES_DIR }}/debian-package"

352+ DPKG_DIR="${DPKG_STAGING}/dpkg"

353+ mkdir -p "${DPKG_DIR}"

310354

311− # Man page

312− 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"

313− gzip --best "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"

355+ DPKG_BASENAME=${PROJECT_NAME}

356+ DPKG_CONFLICTS=${PROJECT_NAME}-musl

357+ case ${{ matrix.job.target }} in *-musl) DPKG_BASENAME=${PROJECT_NAME}-musl ; DPKG_CONFLICTS=${PROJECT_NAME} ;; esac;

358+ DPKG_VERSION=${PROJECT_VERSION}

314359

315− # Autocompletion files

316− 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"

317− 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 }}"

360+ unset DPKG_ARCH

361+ case ${{ matrix.job.target }} in

362+ aarch64-*-linux-*) DPKG_ARCH=arm64 ;;

363+ arm-*-linux-*hf) DPKG_ARCH=armhf ;;

364+ i686-*-linux-*) DPKG_ARCH=i686 ;;

365+ x86_64-*-linux-*) DPKG_ARCH=amd64 ;;

366+ *) DPKG_ARCH=notset ;;

367+ esac;

318368

319− # README and LICENSE

320− install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${{ env.PROJECT_NAME }}/README.md"

321− install -Dm644 "LICENSE-MIT" "${DPKG_DIR}/usr/share/doc/${{ env.PROJECT_NAME }}/LICENSE-MIT"

322− install -Dm644 "LICENSE-APACHE" "${DPKG_DIR}/usr/share/doc/${{ env.PROJECT_NAME }}/LICENSE-APACHE"

369+ DPKG_NAME="${DPKG_BASENAME}_${DPKG_VERSION}_${DPKG_ARCH}.deb"

370+ echo ::set-output name=DPKG_NAME::${DPKG_NAME}

323371

324− cat > "${DPKG_DIR}/usr/share/doc/${{ env.PROJECT_NAME }}/copyright" <<EOF

372+ # Binary

373+ install -Dm755 "${{ steps.strip.outputs.BIN_PATH }}" "${DPKG_DIR}/usr/bin/${{ steps.strip.outputs.BIN_NAME }}"

374+

375+ # Man page

376+ 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"

377+ gzip -n --best "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"

378+

379+ # Autocompletion files

380+ install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/bat.bash "${DPKG_DIR}/usr/share/bash-completion/completions/${{ env.PROJECT_NAME }}"

381+ 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"

382+ 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 }}"

383+

384+ # README and LICENSE

385+ install -Dm644 "README.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/README.md"

386+ install -Dm644 "LICENSE-MIT" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-MIT"

387+ install -Dm644 "LICENSE-APACHE" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/LICENSE-APACHE"

388+ install -Dm644 "CHANGELOG.md" "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/changelog"

389+ gzip -n --best "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/changelog"

390+

391+ cat > "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright" <<EOF

325392 Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/

326393 Upstream-Name: ${{ env.PROJECT_NAME }}

327394 Source: ${{ env.PROJECT_HOMEPAGE }}

328395

329396 Files: *

330397 Copyright: ${{ env.PROJECT_MAINTAINER }}

398+ Copyright: $COPYRIGHT_YEARS ${{ env.PROJECT_MAINTAINER }}

331399 License: Apache-2.0 or MIT

332400

333401 License: Apache-2.0

334− On Debian systems, the complete text of the Apache-2.0 can be found in the

335− file /usr/share/common-licenses/Apache-2.0.

402+ On Debian systems, the complete text of the Apache-2.0 can be found in the

403+ file /usr/share/common-licenses/Apache-2.0.

336404

337405 License: MIT

338− Permission is hereby granted, free of charge, to any

339− person obtaining a copy of this software and associated

340− documentation files (the "Software"), to deal in the

341− Software without restriction, including without

342− limitation the rights to use, copy, modify, merge,

343− publish, distribute, sublicense, and/or sell copies of

344− the Software, and to permit persons to whom the Software

345− is furnished to do so, subject to the following

346− conditions:

347− .

348− The above copyright notice and this permission notice

349− shall be included in all copies or substantial portions

350− of the Software.

351− .

352− THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF

353− ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED

354− TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A

355− PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT

356− SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

357− CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

358− OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR

359− IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

360− DEALINGS IN THE SOFTWARE.

406+ Permission is hereby granted, free of charge, to any

407+ person obtaining a copy of this software and associated

408+ documentation files (the "Software"), to deal in the

409+ Software without restriction, including without

410+ limitation the rights to use, copy, modify, merge,

411+ publish, distribute, sublicense, and/or sell copies of

412+ the Software, and to permit persons to whom the Software

413+ is furnished to do so, subject to the following

414+ conditions:

415+ .

416+ The above copyright notice and this permission notice

417+ shall be included in all copies or substantial portions

418+ of the Software.

419+ .

420+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF

421+ ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED

422+ TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A

423+ PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT

424+ SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

425+ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

426+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR

427+ IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

428+ DEALINGS IN THE SOFTWARE.

361429 EOF

430+ chmod 644 "${DPKG_DIR}/usr/share/doc/${DPKG_BASENAME}/copyright"

362431

363432 # control file

364433 mkdir -p "${DPKG_DIR}/DEBIAN"

365434 cat > "${DPKG_DIR}/DEBIAN/control" <<EOF

366− Package: ${{ steps.vars.outputs.DPKG_BASENAME }}

367− Version: ${{ steps.vars.outputs.DPKG_VERSION }}

435+ Package: ${DPKG_BASENAME}

436+ Version: ${DPKG_VERSION}

368437 Section: utils

369438 Priority: optional

370439 Maintainer: ${{ env.PROJECT_MAINTAINER }}

371440 Homepage: ${{ env.PROJECT_HOMEPAGE }}

372− Architecture: ${{ steps.vars.outputs.DPKG_ARCH }}

441+ Architecture: ${DPKG_ARCH}

373442 Provides: ${{ env.PROJECT_NAME }}

374− Conflicts: ${{ steps.vars.outputs.DPKG_CONFLICTS }}

375− Description: A cat(1) clone with wings.

376− A cat(1) clone with syntax highlighting and Git integration.

443+ Conflicts: ${DPKG_CONFLICTS}

444+ Description: cat(1) clone with wings.

445+ A cat(1) clone with syntax highlighting and Git integration.

377446 EOF

378447

379− # build dpkg

380− fakeroot dpkg-deb --build "${DPKG_DIR}" "${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.DPKG_NAME }}"

381− fi

382− - name: Publish archives and packages

383− uses: softprops/action-gh-release@v1

384− if: steps.vars.outputs.DEPLOY

448+ DPKG_PATH="${DPKG_STAGING}/${DPKG_NAME}"

449+ echo ::set-output name=DPKG_PATH::${DPKG_PATH}

450+

451+ # build dpkg

452+ fakeroot dpkg-deb --build "${DPKG_DIR}" "${DPKG_PATH}"

453+

454+ - name: "Artifact upload: tarball"

455+ uses: actions/upload-artifact@master

385456 with:

386− files: |

387− ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_NAME }}

388− ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.DPKG_NAME }}

389− env:

390− GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

457+ name: ${{ steps.package.outputs.PKG_NAME }}

458+ path: ${{ steps.package.outputs.PKG_PATH }}

391459

392− coverage:

393− name: Code Coverage

394− runs-on: ${{ matrix.job.os }}

395− strategy:

396− fail-fast: true

397− matrix:

398− # job: [ { os: ubuntu-latest }, { os: macos-latest }, { os: windows-latest } ]

399− job:

400− - { os: ubuntu-latest , toolchain: nightly-2020-04-29 }

401− - { os: macos-latest , toolchain: nightly-2020-04-29 }

402− - { os: windows-latest , toolchain: nightly-2020-04-29-x86_64-pc-windows-gnu }

403− steps:

404− - uses: actions/checkout@v2

405− - name: Initialize workflow variables

406− id: vars

460+ - name: "Artifact upload: Debian package"

461+ uses: actions/upload-artifact@master

462+ if: steps.debian-package.outputs.DPKG_NAME

463+ with:

464+ name: ${{ steps.debian-package.outputs.DPKG_NAME }}

465+ path: ${{ steps.debian-package.outputs.DPKG_PATH }}

466+

467+ - name: Check for release

468+ id: is-release

407469 shell: bash

408470 run: |

409− # toolchain

410− TOOLCHAIN="nightly" ## default to "nightly" toolchain

411− # * use requested TOOLCHAIN if specified

412− if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi

413− # * use requested TOOLCHAIN if specified

414− if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi

415− echo set-output name=TOOLCHAIN::${TOOLCHAIN}

416− echo ::set-output name=TOOLCHAIN::${TOOLCHAIN}

417− # target-specific options

418− # * CODECOV_FLAGS

419− CODECOV_FLAGS=$( echo "${{ matrix.job.os }}" | sed 's/[^[:alnum:]]/_/g' )

420− echo set-output name=CODECOV_FLAGS::${CODECOV_FLAGS}

421− echo ::set-output name=CODECOV_FLAGS::${CODECOV_FLAGS}

422− - name: rust toolchain ~ install

423− uses: actions-rs/toolchain@v1

424− with:

425− toolchain: ${{ steps.vars.outputs.TOOLCHAIN }}

426− override: true

427− profile: minimal # minimal component installation (ie, no documentation)

428− - name: Test

429− uses: actions-rs/cargo@v1

471+ unset IS_RELEASE ; if [[ $GITHUB_REF =~ ^refs/tags/v[0-9].* ]]; then IS_RELEASE='true' ; fi

472+ echo ::set-output name=IS_RELEASE::${IS_RELEASE}

473+

474+ - name: Publish archives and packages

475+ uses: softprops/action-gh-release@v1

476+ if: steps.is-release.outputs.IS_RELEASE

430477 with:

431− command: test

432− args: --no-fail-fast

478+ files: |

479+ ${{ steps.package.outputs.PKG_PATH }}

480+ ${{ steps.debian-package.outputs.DPKG_PATH }}

433481 env:

434− CARGO_INCREMENTAL: '0'

435− RUSTFLAGS: '-Zprofile -Ccodegen-units=1 -Cinline-threshold=0 -Clink-dead-code -Coverflow-checks=off -Zno-landing-pads'

436− - name: Generate coverage data

437− id: coverage

438− uses: actions-rs/grcov@v0.1

439− - name: Upload coverage results (to Codecov.io)

440− uses: codecov/codecov-action@v1

441− with:

442− file: ${{ steps.coverage.outputs.report }}

443− flags: ${{ steps.vars.outputs.CODECOV_FLAGS }}

444− name: codecov-umbrella

445− fail_ci_if_error: false

482+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore+1

@@ -2,6 +2,7 @@

22**/*.rs.bk

44# Generated files

5+/assets/completions/bat.bash

56/assets/completions/bat.fish

67/assets/completions/bat.zsh

78/assets/manual/bat.1

.gitmodules+54−16

@@ -61,18 +61,12 @@

6161[submodule "assets/syntaxes/Puppet"]

6262 path = assets/syntaxes/02_Extra/Puppet

6363 url = https://github.com/russCloak/SublimePuppet

64−[submodule "assets/syntaxes/CSV"]

65− path = assets/syntaxes/02_Extra/CSV

66− url = https://github.com/wadetb/Sublime-Text-Advanced-CSV

6764[submodule "assets/themes/onehalf"]

6865 path = assets/themes/onehalf

6966 url = https://github.com/sonph/onehalf

7067[submodule "assets/syntaxes/JavaScript (Babel)"]

7168 path = assets/syntaxes/02_Extra/JavaScript (Babel)

7269 url = https://github.com/babel/babel-sublime

73−[submodule "assets/syntaxes/Dart"]

74− path = assets/syntaxes/02_Extra/Dart

75− url = https://github.com/guillermooo/dart-sublime-bundle

7670[submodule "assets/syntaxes/FSharp"]

7771 path = assets/syntaxes/02_Extra/FSharp

7872 url = https://github.com/hoest/sublimetext-fsharp

@@ -97,10 +91,6 @@

9791[submodule "assets/syntaxes/Assembly (ARM)"]

9892 path = assets/syntaxes/02_Extra/Assembly (ARM)

9993 url = https://github.com/tvi/Sublime-ARM-Assembly

100−[submodule "assets/syntaxes/syslog-syntax"]

101− path = assets/syntaxes/02_Extra/Syslog

102− url = https://github.com/caos21/syslog-syntax.git

103− branch = master

10494[submodule "assets/syntaxes/protobuf-syntax-highlighting"]

10595 path = assets/syntaxes/02_Extra/Protobuf

10696 url = https://github.com/VcamX/protobuf-syntax-highlighting.git

@@ -120,9 +110,6 @@

120110[submodule "assets/syntaxes/Org mode"]

121111 path = assets/syntaxes/02_Extra/Org mode

122112 url = https://github.com/jezcope/Org.tmbundle.git

123−[submodule "assets/syntaxes/requirementstxt"]

124− path = assets/syntaxes/02_Extra/requirementstxt

125− url = https://github.com/wuub/requirementstxt

126113[submodule "assets/syntaxes/DotENV"]

127114 path = assets/syntaxes/02_Extra/DotENV

128115 url = https://github.com/zaynali53/DotENV

@@ -185,9 +172,6 @@

185172[submodule "assets/syntaxes/02_Extra/AsciiDoc"]

186173 path = assets/syntaxes/02_Extra/AsciiDoc

187174 url = https://github.com/asciidoctor/sublimetext-asciidoc.git

188−[submodule "assets/themes/gruvbox"]

189− path = assets/themes/gruvbox

190− url = https://github.com/peaceant/gruvbox.git

191175[submodule "assets/syntaxes/02_Extra/GLSL"]

192176 path = assets/syntaxes/02_Extra/GLSL

193177 url = https://github.com/euler0/sublime-glsl

@@ -206,3 +190,57 @@

206190[submodule "assets/themes/Coldark"]

207191 path = assets/themes/Coldark

208192 url = https://github.com/ArmandPhilippot/coldark-bat.git

193+[submodule "assets/themes/gruvbox"]

194+ path = assets/themes/gruvbox

195+ url = https://github.com/subnut/gruvbox-tmTheme.git

196+ branch = bat-source

197+[submodule "assets/syntaxes/02_Extra/Lean"]

198+ path = assets/syntaxes/02_Extra/Lean

199+ url = https://github.com/leanprover/vscode-lean.git

200+[submodule "assets/syntaxes/02_Extra/LiveScript"]

201+ path = assets/syntaxes/02_Extra/LiveScript

202+ url = https://github.com/paulmillr/LiveScript.tmbundle

203+[submodule "assets/syntaxes/02_Extra/Zig"]

204+ path = assets/syntaxes/02_Extra/Zig

205+ url = https://github.com/ziglang/sublime-zig-language.git

206+[submodule "assets/syntaxes/02_Extra/gnuplot"]

207+ path = assets/syntaxes/02_Extra/gnuplot

208+ url = https://github.com/hesstobi/sublime_gnuplot

209+[submodule "assets/syntaxes/02_Extra/SystemVerilog"]

210+ path = assets/syntaxes/02_Extra/SystemVerilog

211+ url = https://github.com/TheClams/SystemVerilog.git

212+[submodule "assets/themes/visual-studio-dark-plus"]

213+ path = assets/themes/visual-studio-dark-plus

214+ url = https://github.com/vidann1/visual-studio-dark-plus.git

215+[submodule "assets/syntaxes/02_Extra/SublimeEthereum"]

216+ path = assets/syntaxes/02_Extra/SublimeEthereum

217+ url = https://github.com/davidhq/SublimeEthereum.git

218+[submodule "assets/syntaxes/02_Extra/Groff"]

219+ path = assets/syntaxes/02_Extra/Groff

220+ url = https://github.com/carsonoid/sublime_man_page_support

221+[submodule "assets/syntaxes/02_Extra/http-request-response"]

222+ path = assets/syntaxes/02_Extra/http-request-response

223+ url = https://github.com/keith-hall/http-request-response-syntax.git

224+[submodule "assets/syntaxes/02_Extra/LLVM"]

225+ path = assets/syntaxes/02_Extra/LLVM

226+ url = https://github.com/ioncodes/LLVM.tmBundle

227+[submodule "assets/syntaxes/02_Extra/Slim"]

228+ path = assets/syntaxes/02_Extra/Slim

229+ url = https://github.com/slim-template/ruby-slim.tmbundle.git

230+[submodule "assets/syntaxes/02_Extra/Racket"]

231+ path = assets/syntaxes/02_Extra/Racket

232+ url = https://github.com/follesoe/sublime-racket.git

233+[submodule "assets/syntaxes/02_Extra/MediaWiki"]

234+ path = assets/syntaxes/02_Extra/MediaWiki

235+ url = https://github.com/tosher/Mediawiker.git

236+[submodule "assets/syntaxes/02_Extra/Dart"]

237+ path = assets/syntaxes/02_Extra/Dart

238+ url = https://github.com/elMuso/Dartlight.git

239+[submodule "assets/syntaxes/02_Extra/SublimeJQ"]

240+ path = assets/syntaxes/02_Extra/SublimeJQ

241+ url = https://github.com/zogwarg/SublimeJQ.git

242+[submodule "assets/syntaxes/02_Extra/cmd-help"]

243+ path = assets/syntaxes/02_Extra/cmd-help

244+ url = https://github.com/victor-gp/cmd-help-sublime-syntax.git

245+ branch = main

246+ shallow = true

CHANGELOG.md+230−5

@@ -1,19 +1,247 @@

11# unreleased

3+## Features

5+- Make the default macOS theme depend on Dark Mode. See #2197, #1746 (@Enselic)

7+## Bugfixes

9+## Other

10+

11+- Relaxed glibc requirements on amd64, see #2106 and #2194 (@sharkdp)

12+

13+## Syntaxes

14+

15+## Themes

16+

17+## `bat` as a library

18+

19+

20+# v0.21.0

21+

22+## Features

23+

24+- Correctly render tab stops in `--show-all`, see #2038 (@Synthetica9)

25+- Add a `--style=default` option and make it the default. It is less verbose than `full`, see #2061 (@IsaacHorvath)

26+- Enable BusyBox `less` as pager, see #2162 (@nfisher1226)

27+- File extensions are now matched case-insensitively. See #1854, #2181 (@Enselic)

28+

29+## Bugfixes

30+

31+- 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)

32+- `bat` no longer crashes when encountering files that references missing syntaxes. See #915, #2181 (@Enselic)

33+

34+## Performance

35+

36+- Skip syntax highlighting on long lines (> 16384 chars) to help improve performance. See #2165 (@keith-hall)

37+- 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)

38+

39+## Other

40+

41+- Include info about custom assets in `--diagnostics` if used. See #2107, #2144 (@Enselic)

42+

43+## Syntaxes

44+

45+- Mapped clang-format config file (.clang-format) to YAML syntax (@TruncatedDinosour)

46+- log syntax: improved handling of escape characters in double quoted strings. See #2123 (@keith-hall)

47+- Associate `/var/spool/mail/*` and `/var/mail/*` with the `Email` syntax. See #2156 (@cyqsimon)

48+- Added cmd-help syntax to scope --help messages. See #2148 (@victor-gp)

49+- Slightly adjust Zig syntax. See #2136 (@Enselic)

50+- Associate `.inf` files with the `INI` syntax. See #2190 (@Enselic)

51+

52+## `bat` as a library

53+

54+- Allow configuration of `show_nonprintable` with `PrettyPrinter`, see #2142

55+- The binary format of syntaxes.bin has been changed due to syntaxes now being lazy-loaded via syntect 5.0.0. See #2181 (@Enselic)

56+- Mark `bat::error::Error` enum as `#[non_exhaustive]` to allow adding new variants without future semver breakage. See #2181 (@Enselic)

57+- Change `Error::SyntectError(syntect::LoadingError)` to `Error::SyntectError(syntect::Error)`. See #2181 (@Enselic)

58+- Add `Error::SyntectLoadingError(syntect::LoadingError)` enum variant. See #2181 (@Enselic)

59+

60+

61+# v0.20.0

62+

63+## Features

64+

65+- New style component `header-filesize` to show size of the displayed file in the header. See #1988 (@mdibaiee)

66+- Use underline for line highlighting on ANSI, see #1730 (@mdibaiee)

67+

68+## Bugfixes

69+

70+- Fix bash completion on bash 3.x and bash-completion 1.x. See #2066 (@joshpencheon)

71+

72+## Syntaxes

73+

74+- `GraphQL`: Add support for interfaces implementing interfaces and consider ampersand an operator. See #2000

75+- Associate `_vimrc` and `_gvimrc` files with the `VimL` syntax. See #2002

76+- Associate `poetry.lock` files with the `TOML` syntax. See #2049

77+- Associate `.mesh`, `.task`, `.rgen`, `.rint`, `.rahit`, `.rchit`, `.rmiss`, and `.rcall` with the `GLSL` syntax. See #2050

78+- Added support for `JQ` syntax, see #2072

79+- Properly associate global git config files rooted in `$XDG_CONFIG_HOME/git/` or `$HOME/.config/git/`. See #2067 (@cyqsimon)

80+

81+## `bat` as a library

82+

83+- Exposed `get_syntax_set` and `get_theme` methods on `HighlightingAssets`. See #2030 (@dandavison)

84+- Added `HeaderFilename` and `HeaderFilesize` to `StyleComponent` enum, and mark it `#[non_exhaustive]`. See #1988 (@mdibaiee)

85+

86+

87+# v0.19.0

88+

89+## Performance

90+

91+- Reduce startup time in loop-through mode (e.g. when redirecting output) by 90%. See #1747 (@Enselic)

92+- Load themes lazily to make bat start 25% faster when disregarding syntax load time. See #1969 (@Enselic)

93+- Python syntax highlighting no longer suffers from abysmal performance in specific scenarios. See #1688 (@keith-hall)

94+- Fix for poor performance when ANSI escape sequences are piped to `bat`, see #1596 (@eth-p)

95+- Fix for incorrect handling of ANSI escape sequences when using `--wrap=never`, see #1596 (@eth-p)

96+- Load custom assets as fast as integrated assets, see #1753 (@Enselic)

97+

98+## Features

99+

100+- Support for `x:-delta` (minus) syntax in line ranges (e.g. `20:-10`). See #1901 (@bojan88)

101+- Support for `--ignored-suffix` argument. See #1892 (@bojan88)

102+- `$BAT_CONFIG_DIR` is now a recognized environment variable. It has precedence over `$XDG_CONFIG_HOME`, see #1727 (@billrisher)

103+- Support for `x:+delta` syntax in line ranges (e.g. `20:+10`). See #1810 (@bojan88)

104+- Add new `--acknowledgements` option that gives credit to theme and syntax definition authors. See #1971 (@Enselic)

105+- Include git hash in `bat -V` and `bat --version` output if present. See #1921 (@Enselic)

106+

107+## Bugfixes

108+

109+- First line not shown in diff context. See #1891 (@divagant-martian)

110+- Do not ignore syntaxes that handle file names with a `*.conf` extension. See #1703 (@cbolgiano)

111+

112+## Other

113+

114+- Add PowerShell completion, see #1826 (@rashil2000)

115+- Minimum supported Rust version (MSRV) bumped to 1.51, see #1994 (@mdibaiee)

116+

117+## Syntaxes

118+

119+- Groff, see #1685 (@scop)

120+- HTTP Requests and Responses, see #1748 (@keith-hall)

121+- LLVM, see #1777 (@ioncodes)

122+- Highlight for `vimrc` and `gvimrc` files, see #1763 (@SuperSandro2000)

123+- Syslog highlighting improvements, see #1793 (@scop)

124+- Added support for `slim` syntax, see #1693 (@mfinelli)

125+- Racket, see #1884 (@jubnzv)

126+- LiveScript, see #1915 (@Enselic)

127+- MediaWiki, see #1925 (@sorairolake)

128+- The `requirements.txt` syntax has been removed due to incompatible license requirements.

129+- Dart, new highlighter, see #1959 (@Ersikan)

130+- SCSS and Sass syntaxes updated, see #1766 (@Enselic)

131+- PowerShell syntax updated, see #1935 (@Enselic)

132+- TypeScript syntax updated, see #1834 (@Enselic)

133+

134+## `bat` as a library

135+

136+- 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)

137+- 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)

138+- 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)

139+- 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)

140+

141+

142+# v0.18.3

143+

144+## Bugfixes

145+

146+- Bump `git2` dependency to fix build with Rust 1.54, see #1761

147+

148+

149+# v0.18.2

3150

4151## Features

5152

153+- Ignore known backup/template filename suffixes when selecting the syntax, see #1687 (@scop)

154+

6155## Bugfixes

7156

157+- Fix for a security vulnerability on Windows. Prior to this release, `bat` would execute programs called `less`/`less.exe` from the current working directory (instead of the one from `PATH`) with priority. An attacker might be able to use this by placing a malicious program in a shared directory where the user would execute `bat`. `bat` users on Windows are advised to upgrade to this version. See #1724 and #1472 (@Ry0taK).

158+

8159## Other

9160

161+- Add bash completion, see #1678 (@scop)

162+- Fix Clippy lints, see #1661 (@mohamed-abdelnour)

163+- Add syntax highlighting test files, see #1213 and #1668 (@mohamed-abdelnour)

164+

10165## Syntaxes

11166

167+- Upgraded Julia syntax to fix a highlighting bug, see #1692

168+- Added support for `dash` syntax, see #1654 (@mohamed-abdelnour)

169+- Added support for `XAML` syntax, see #1590 and #1655 (@mohamed-abdelnour)

170+- Apply `DotENV` syntax also for `.env.default` and `.env.defaults` files, see #1669

171+

172+

173+# v0.18.1

174+

175+## Bugfixes

176+

177+- Mouse support and screen clearing broken for `less` versions with minor version number (581.2), see #1629 and #1639 (@aswild)

178+

179+## Other

180+

181+- `Input::ordinary_file` and `Input::with_name` now accept `Path` rather than `OsStr` see #1571 (@matklad)

182+- The `LESS` environment variable is now included in `bat --diagnostic`, see #1589 (@Enselic)

183+- Increased min. required Rust version to 1.45

184+

185+## Syntaxes

186+

187+- Improved the Syslog syntax highlighting, see #1606 (@keith-hall)

188+- Replaced "Advanced CSV" with a custom CSV syntax definition written especially for `bat`; see #1574 (@keith-hall)

189+- Added SystemVerilog file syntax, see #1580 (@SeanMcLoughlin)

190+- Added Solidity and Vyper syntax, see #1602 (@Ersikan)

191+

12192## New themes

13193

194+- Dark+ VS Code theme, see #1588 and #1598 (@PatriotRossii)

195+

196+

197+

198+# v0.18.0

199+

200+## Features

201+

202+- Use a pager when `bat --list-languages` is called, see #1394 (@stku1985)

203+

204+## Bugfixes

205+

206+- If the last line doesn't end with a newline character, don't add it if `--style=plain`, see #1438 (@Enselic)

207+- Only print themes hint in interactive mode (`bat --list-themes`), see #1439 (@rsteube)

208+- Make ./tests/syntax-tests/regression_test.sh work on recent versions of macOS, see #1443 (@Enselic)

209+- VimL syntax highlighting fix, see #1450 (@esensar)

210+- Print an 'Invalid syntax theme settings' error message if a custom theme is broken, see #614 (@Enselic)

211+- If plain mode is set and wrap is not explicitly opted in, long lines will no be truncated, see #1426

212+- If `PAGER` (but not `BAT_PAGER` or `--pager`) is `more` or `most`, silently use `less` instead to ensure support for colors, see #1063 (@Enselic)

213+- If `PAGER` is `bat`, silently use `less` to prevent recursion. For `BAT_PAGER` or `--pager`, exit with error, see #1413 (@Enselic)

214+- Manpage highlighting fix, see #1511 (@keith-hall)

215+- `BAT_CONFIG_PATH` ignored by `bat` if non-existent, see #1550 (@sharkdp)

216+

217+## Other

218+

219+- Performance improvements, see #1421 (@LovecraftianHorror)

220+- Added a new `--diagnostic` option to collect information for bug reports, see #1459 (@sharkdp)

221+- Modified default theme colors to differentiate between a JSON key and a string value, see #1400 (@keith-hall)

222+- Upped min required Rust version to 1.42

223+

224+## Syntaxes

225+

226+- Added Zig syntax, see #1470 (@paulsmith)

227+- Added Lean syntax, see #1446 (@Julian)

228+- Added `.resource` extension for Robot Framework files, see #1386

229+- Added `gnuplot` syntax, see #1431 (@sharkdp)

230+- Highlight *.pac (Proxy auto-config) files as JavaScript, see #1515 (@sharkdp)

231+

232+## New themes

233+

234+- `ansi` replaces `ansi-dark` and `ansi-light`, see #1104 and #1412 (@mk12). **Breaking change:** users that were previously using one of the `ansi-*` themes should switch to `ansi`.

235+- The Gruvbox theme has been updated, see #1291 (@j0hnmeow). **Breaking change:** users that were previously using `gruvbox` or `gruvbox-white` should update and use `gruvbox-dark`/`gruvbox-light` instead.

236+

14237## `bat` as a library

15238

16−## Packaging

239+- The following `PrettyPrinter` methods have been removed (they were previously deprecated):

240+ - `input_stdin_with_name`

241+ - `input_from_bytes_with_name`

242+ - `input_from_reader_with_name`

243+ - `vcs_modification_markers` (if the `git` feature is not enabled)

244+

17245

18246# v0.17.1

19247

@@ -21,9 +249,6 @@

21249

22250- Running `bat` without arguments fails ("output file is also an input"), see #1396

23251

24−## Packaging

25−

26−- `bat` is now available on snapstore with package name called `batwing`, see #1401 (@purveshpatel511)

27252

28253# v0.17.0

29254

@@ -460,7 +685,7 @@ You can see the API documentation here: https://docs.rs/bat/

460685

461686- Added `BAT_CONFIG_PATH` environment variable to set a non-default path for `bat`s configuration file, see #375 (@deg4uss3r)

462687

463−- Allow for multiple occurences of `--style` to allow for the configuration

688+- Allow for multiple occurrences of `--style` to allow for the configuration

464689 of styles from the config file, see #367 (@sindreij)

465690

466691- Allow for multiple `--line-range` arguments, see #23

CONTRIBUTING.md+22

@@ -46,3 +46,25 @@ If you really think that a particular syntax or theme should be added for all

4646users, please read the corresponding

4747[documentation](https://github.com/sharkdp/bat/blob/master/doc/assets.md)

4848first.

49+

50+

51+## Regression tests

52+

53+You are strongly encouraged to add regression tests. Regression tests are great,

54+not least because they:

55+

56+* ensure that your contribution will never completely stop working,

57+

58+* makes code review easier, because it becomes very clear what the code is

59+ supposed to do.

60+

61+For functional changes, you most likely want to add a test to

62+[`tests/integration_tests.rs`](https://github.com/sharkdp/bat/blob/master/tests/integration_tests.rs).

63+Look at existing tests to know how to write a new test. In short, you will

64+invoke the `bat` binary with a certain set of arguments, and then assert on

65+stdout/stderr.

66+

67+To learn how to write regression tests for theme and syntax changes, read the

68+[Syntax

69+tests](https://github.com/sharkdp/bat/blob/master/doc/assets.md#syntax-tests)

70+section in `assets.md`.

Cargo.lock+467−426

@@ -1,36 +1,29 @@

11# This file is automatically @generated by Cargo.

22# It is not intended for manual editing.

3+version = 3

35[[package]]

46name = "adler"

5−version = "0.2.3"

7+version = "1.0.2"

68source = "registry+https://github.com/rust-lang/crates.io-index"

7−checksum = "ee2a4ec343196209d6594e19543ae87a39f96d5534d7174822a3ad825dd6ed7e"

9+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"

810

911[[package]]

1012name = "aho-corasick"

11−version = "0.7.13"

13+version = "0.7.18"

1214source = "registry+https://github.com/rust-lang/crates.io-index"

13−checksum = "043164d8ba5c4c3035fec9bbee8647c0261d788f3474306f93bb65901cae0e86"

15+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"

1416dependencies = [

1517 "memchr",

1618]

1719

1820[[package]]

1921name = "ansi_colours"

20−version = "1.0.1"

21−source = "registry+https://github.com/rust-lang/crates.io-index"

22−checksum = "1d0f302a81afc6a7f4350c04f0ba7cfab529cc009bca3324b3fb5764e6add8b6"

23−dependencies = [

24− "cc",

25−]

26−

27−[[package]]

28−name = "ansi_term"

29−version = "0.11.0"

22+version = "1.1.1"

3023source = "registry+https://github.com/rust-lang/crates.io-index"

31−checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"

24+checksum = "32678233b67f9056b0c144b39d46dc3218637e8d84ad6038ded339e08b19620d"

3225dependencies = [

33− "winapi",

26+ "rgb",

3427]

3528

3629[[package]]

@@ -42,24 +35,13 @@ dependencies = [

4235 "winapi",

4336]

4437

45−[[package]]

46−name = "arrayref"

47−version = "0.3.6"

48−source = "registry+https://github.com/rust-lang/crates.io-index"

49−checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"

50−

51−[[package]]

52−name = "arrayvec"

53−version = "0.5.1"

54−source = "registry+https://github.com/rust-lang/crates.io-index"

55−checksum = "cff77d8686867eceff3105329d4698d96c2391c176d5d03adc90c7389162b5b8"

56−

5738[[package]]

5839name = "assert_cmd"

59−version = "1.0.2"

40+version = "2.0.4"

6041source = "registry+https://github.com/rust-lang/crates.io-index"

61−checksum = "3dc1679af9a1ab4bea16f228b05d18f8363f8327b1fa8db00d2760cfafc6b61e"

42+checksum = "93ae1ddd39efd67689deb1979d80bad3bf7f2b09c6e6117c8d1f2443b5e2f83e"

6243dependencies = [

44+ "bstr",

6345 "doc-comment",

6446 "predicates",

6547 "predicates-core",

@@ -86,46 +68,56 @@ checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"

8668

8769[[package]]

8870name = "base64"

89−version = "0.12.3"

71+version = "0.13.0"

9072source = "registry+https://github.com/rust-lang/crates.io-index"

91−checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff"

73+checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"

9274

9375[[package]]

9476name = "bat"

95−version = "0.17.1"

77+version = "0.21.0"

9678dependencies = [

9779 "ansi_colours",

98− "ansi_term 0.12.1",

80+ "ansi_term",

9981 "assert_cmd",

10082 "atty",

83+ "bincode",

84+ "bugreport",

85+ "bytesize",

10186 "clap",

87+ "clircle",

10288 "console",

10389 "content_inspector",

104− "dirs",

90+ "dirs-next",

10591 "encoding",

106− "error-chain",

92+ "flate2",

10793 "git2",

10894 "globset",

109− "lazy_static",

95+ "grep-cli",

96+ "nix",

97+ "once_cell",

11098 "path_abs",

11199 "predicates",

100+ "regex",

112101 "semver",

113102 "serde",

114103 "serde_yaml",

104+ "serial_test",

115105 "shell-words",

116106 "syntect",

117− "tempdir",

107+ "tempfile",

108+ "thiserror",

118109 "unicode-width",

110+ "wait-timeout",

111+ "walkdir",

119112 "wild",

120113]

121114

122115[[package]]

123116name = "bincode"

124−version = "1.3.1"

117+version = "1.3.3"

125118source = "registry+https://github.com/rust-lang/crates.io-index"

126−checksum = "f30d3a39baa26f9651f17b375061f3233dde33424a8b72b0dbe93a68a0bc896d"

119+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"

127120dependencies = [

128− "byteorder",

129121 "serde",

130122]

131123

@@ -140,101 +132,72 @@ dependencies = [

140132

141133[[package]]

142134name = "bit-vec"

143−version = "0.6.2"

135+version = "0.6.3"

144136source = "registry+https://github.com/rust-lang/crates.io-index"

145−checksum = "5f0dc55f2d8a1a85650ac47858bb001b4c0dd73d79e3c455a842925e68d29cd3"

137+checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"

146138

147139[[package]]

148140name = "bitflags"

149−version = "1.2.1"

150−source = "registry+https://github.com/rust-lang/crates.io-index"

151−checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"

152−

153−[[package]]

154−name = "blake2b_simd"

155−version = "0.5.10"

141+version = "1.3.2"

156142source = "registry+https://github.com/rust-lang/crates.io-index"

157−checksum = "d8fb2d74254a3a0b5cac33ac9f8ed0e44aa50378d9dbb2e5d83bd21ed1dc2c8a"

158−dependencies = [

159− "arrayref",

160− "arrayvec",

161− "constant_time_eq",

162−]

143+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

163144

164145[[package]]

165−name = "block-buffer"

166−version = "0.7.3"

167−source = "registry+https://github.com/rust-lang/crates.io-index"

168−checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"

169−dependencies = [

170− "block-padding",

171− "byte-tools",

172− "byteorder",

173− "generic-array",

174−]

175−

176−[[package]]

177−name = "block-padding"

178−version = "0.1.5"

146+name = "bstr"

147+version = "0.2.17"

179148source = "registry+https://github.com/rust-lang/crates.io-index"

180−checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"

149+checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"

181150dependencies = [

182− "byte-tools",

151+ "lazy_static",

152+ "memchr",

153+ "regex-automata",

183154]

184155

185156[[package]]

186−name = "bstr"

187−version = "0.2.13"

157+name = "bugreport"

158+version = "0.5.0"

188159source = "registry+https://github.com/rust-lang/crates.io-index"

189−checksum = "31accafdb70df7871592c058eca3985b71104e15ac32f64706022c58867da931"

160+checksum = "535120b8182547808081a66f1f77a64533c780b23da26763e0ee34dfb94f98c9"

190161dependencies = [

191− "memchr",

162+ "git-version",

163+ "shell-escape",

164+ "sys-info",

192165]

193166

194167[[package]]

195−name = "byte-tools"

196−version = "0.3.1"

168+name = "bytemuck"

169+version = "1.7.3"

197170source = "registry+https://github.com/rust-lang/crates.io-index"

198−checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"

171+checksum = "439989e6b8c38d1b6570a384ef1e49c8848128f5a97f3914baef02920842712f"

199172

200173[[package]]

201−name = "byteorder"

202−version = "1.3.4"

174+name = "bytesize"

175+version = "1.1.0"

203176source = "registry+https://github.com/rust-lang/crates.io-index"

204−checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"

177+checksum = "6c58ec36aac5066d5ca17df51b3e70279f5670a72102f5752cb7e7c856adfc70"

205178

206179[[package]]

207180name = "cc"

208−version = "1.0.60"

181+version = "1.0.72"

209182source = "registry+https://github.com/rust-lang/crates.io-index"

210−checksum = "ef611cc68ff783f18535d77ddd080185275713d852c4f5cbb6122c462a7a825c"

183+checksum = "22a9137b95ea06864e018375b72adfb7db6e6f68cfc8df5a04d00288050485ee"

211184dependencies = [

212185 "jobserver",

213186]

214187

215188[[package]]

216189name = "cfg-if"

217−version = "0.1.10"

218−source = "registry+https://github.com/rust-lang/crates.io-index"

219−checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"

220−

221−[[package]]

222−name = "chrono"

223−version = "0.4.19"

190+version = "1.0.0"

224191source = "registry+https://github.com/rust-lang/crates.io-index"

225−checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"

226−dependencies = [

227− "num-integer",

228− "num-traits",

229−]

192+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

230193

231194[[package]]

232195name = "clap"

233−version = "2.33.3"

196+version = "2.34.0"

234197source = "registry+https://github.com/rust-lang/crates.io-index"

235−checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"

198+checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"

236199dependencies = [

237− "ansi_term 0.11.0",

200+ "ansi_term",

238201 "atty",

239202 "bitflags",

240203 "strsim",

@@ -244,28 +207,33 @@ dependencies = [

244207 "vec_map",

245208]

246209

210+[[package]]

211+name = "clircle"

212+version = "0.3.0"

213+source = "registry+https://github.com/rust-lang/crates.io-index"

214+checksum = "e68bbd985a63de680ab4d1ad77b6306611a8f961b282c8b5ab513e6de934e396"

215+dependencies = [

216+ "cfg-if",

217+ "libc",

218+ "serde",

219+ "winapi",

220+]

221+

247222[[package]]

248223name = "console"

249−version = "0.13.0"

224+version = "0.15.0"

250225source = "registry+https://github.com/rust-lang/crates.io-index"

251−checksum = "a50aab2529019abfabfa93f1e6c41ef392f91fbf179b347a7e96abb524884a08"

226+checksum = "a28b32d32ca44b70c3e4acd7db1babf555fa026e385fb95f18028f88848b3c31"

252227dependencies = [

253228 "encode_unicode",

254− "lazy_static",

255229 "libc",

230+ "once_cell",

256231 "regex",

257232 "terminal_size",

258233 "unicode-width",

259234 "winapi",

260− "winapi-util",

261235]

262236

263−[[package]]

264−name = "constant_time_eq"

265−version = "0.1.5"

266−source = "registry+https://github.com/rust-lang/crates.io-index"

267−checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"

268−

269237[[package]]

270238name = "content_inspector"

271239version = "0.2.4"

@@ -277,53 +245,34 @@ dependencies = [

277245

278246[[package]]

279247name = "crc32fast"

280−version = "1.2.0"

248+version = "1.3.0"

281249source = "registry+https://github.com/rust-lang/crates.io-index"

282−checksum = "ba125de2af0df55319f41944744ad91c71113bf74a4646efff39afe1f6842db1"

250+checksum = "738c290dfaea84fc1ca15ad9c168d083b05a714e1efddd8edaab678dc28d2836"

283251dependencies = [

284252 "cfg-if",

285253]

286254

287255[[package]]

288−name = "crossbeam-utils"

289−version = "0.7.2"

256+name = "difflib"

257+version = "0.4.0"

290258source = "registry+https://github.com/rust-lang/crates.io-index"

291−checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8"

292−dependencies = [

293− "autocfg",

294− "cfg-if",

295− "lazy_static",

296−]

259+checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"

297260

298261[[package]]

299−name = "difference"

262+name = "dirs-next"

300263version = "2.0.0"

301264source = "registry+https://github.com/rust-lang/crates.io-index"

302−checksum = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198"

303−

304−[[package]]

305−name = "digest"

306−version = "0.8.1"

307−source = "registry+https://github.com/rust-lang/crates.io-index"

308−checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"

265+checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"

309266dependencies = [

310− "generic-array",

311−]

312−

313−[[package]]

314−name = "dirs"

315−version = "3.0.1"

316−source = "registry+https://github.com/rust-lang/crates.io-index"

317−checksum = "142995ed02755914747cc6ca76fc7e4583cd18578746716d0508ea6ed558b9ff"

318−dependencies = [

319− "dirs-sys",

267+ "cfg-if",

268+ "dirs-sys-next",

320269]

321270

322271[[package]]

323−name = "dirs-sys"

324−version = "0.3.5"

272+name = "dirs-sys-next"

273+version = "0.1.2"

325274source = "registry+https://github.com/rust-lang/crates.io-index"

326−checksum = "8e93d7f5705de3e49895a2b5e0b8855a1c27f080192ae9c32a6432d50741a57a"

275+checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"

327276dependencies = [

328277 "libc",

329278 "redox_users",

@@ -337,10 +286,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"

337286checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"

338287

339288[[package]]

340−name = "dtoa"

341−version = "0.4.6"

289+name = "either"

290+version = "1.6.1"

342291source = "registry+https://github.com/rust-lang/crates.io-index"

343−checksum = "134951f4028bdadb9b84baf4232681efbf277da25144b9b0ad65df75946c422b"

292+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"

344293

345294[[package]]

346295name = "encode_unicode"

@@ -413,35 +362,29 @@ source = "registry+https://github.com/rust-lang/crates.io-index"

413362checksum = "a246d82be1c9d791c5dfde9a2bd045fc3cbba3fa2b11ad558f27d01712f00569"

414363

415364[[package]]

416−name = "error-chain"

417−version = "0.12.4"

365+name = "fancy-regex"

366+version = "0.7.1"

418367source = "registry+https://github.com/rust-lang/crates.io-index"

419−checksum = "2d2f06b9cac1506ece98fe3231e3cc9c4410ec3d5b1f24ae1c8946f0742cdefc"

368+checksum = "9d6b8560a05112eb52f04b00e5d3790c0dd75d9d980eb8a122fb23b92a623ccf"

420369dependencies = [

421− "version_check",

370+ "bit-set",

371+ "regex",

422372]

423373

424374[[package]]

425−name = "fake-simd"

426−version = "0.1.2"

427−source = "registry+https://github.com/rust-lang/crates.io-index"

428−checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"

429−

430−[[package]]

431−name = "fancy-regex"

432−version = "0.3.5"

375+name = "fastrand"

376+version = "1.7.0"

433377source = "registry+https://github.com/rust-lang/crates.io-index"

434−checksum = "ae91abf6555234338687bb47913978d275539235fcb77ba9863b779090b42b14"

378+checksum = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"

435379dependencies = [

436− "bit-set",

437− "regex",

380+ "instant",

438381]

439382

440383[[package]]

441384name = "flate2"

442−version = "1.0.18"

385+version = "1.0.23"

443386source = "registry+https://github.com/rust-lang/crates.io-index"

444−checksum = "da80be589a72651dcda34d8b35bcdc9b7254ad06325611074d9cc0fbb19f60ee"

387+checksum = "b39522e96686d38f4bc984b9198e3a0613264abaebaff2c5c918bfa6b6da09af"

445388dependencies = [

446389 "cfg-if",

447390 "crc32fast",

@@ -451,9 +394,9 @@ dependencies = [

451394

452395[[package]]

453396name = "float-cmp"

454−version = "0.8.0"

397+version = "0.9.0"

455398source = "registry+https://github.com/rust-lang/crates.io-index"

456−checksum = "e1267f4ac4f343772758f7b1bdcbe767c218bbab93bb432acbf5162bbf85a6c4"

399+checksum = "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4"

457400dependencies = [

458401 "num-traits",

459402]

@@ -465,36 +408,53 @@ source = "registry+https://github.com/rust-lang/crates.io-index"

465408checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

466409

467410[[package]]

468−name = "fuchsia-cprng"

469−version = "0.1.1"

470−source = "registry+https://github.com/rust-lang/crates.io-index"

471−checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"

472−

473−[[package]]

474−name = "generic-array"

475−version = "0.12.3"

411+name = "form_urlencoded"

412+version = "1.0.1"

476413source = "registry+https://github.com/rust-lang/crates.io-index"

477−checksum = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec"

414+checksum = "5fc25a87fa4fd2094bffb06925852034d90a17f0d1e05197d4956d3555752191"

478415dependencies = [

479− "typenum",

416+ "matches",

417+ "percent-encoding",

480418]

481419

482420[[package]]

483421name = "getrandom"

484−version = "0.1.15"

422+version = "0.2.3"

485423source = "registry+https://github.com/rust-lang/crates.io-index"

486−checksum = "fc587bc0ec293155d5bfa6b9891ec18a1e330c234f896ea47fbada4cadbe47e6"

424+checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"

487425dependencies = [

488426 "cfg-if",

489427 "libc",

490428 "wasi",

491429]

492430

431+[[package]]

432+name = "git-version"

433+version = "0.3.5"

434+source = "registry+https://github.com/rust-lang/crates.io-index"

435+checksum = "f6b0decc02f4636b9ccad390dcbe77b722a77efedfa393caf8379a51d5c61899"

436+dependencies = [

437+ "git-version-macro",

438+ "proc-macro-hack",

439+]

440+

441+[[package]]

442+name = "git-version-macro"

443+version = "0.3.5"

444+source = "registry+https://github.com/rust-lang/crates.io-index"

445+checksum = "fe69f1cbdb6e28af2bac214e943b99ce8a0a06b447d15d3e61161b0423139f3f"

446+dependencies = [

447+ "proc-macro-hack",

448+ "proc-macro2",

449+ "quote",

450+ "syn",

451+]

452+

493453[[package]]

494454name = "git2"

495−version = "0.13.12"

455+version = "0.14.2"

496456source = "registry+https://github.com/rust-lang/crates.io-index"

497−checksum = "ca6f1a0238d7f8f8fd5ee642f4ebac4dbc03e03d1f78fbe7a3ede35dcf7e2224"

457+checksum = "3826a6e0e2215d7a41c2bfc7c9244123969273f3476b939a226aac0ab56e9e3c"

498458dependencies = [

499459 "bitflags",

500460 "libc",

@@ -511,9 +471,9 @@ checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"

511471

512472[[package]]

513473name = "globset"

514−version = "0.4.6"

474+version = "0.4.8"

515475source = "registry+https://github.com/rust-lang/crates.io-index"

516−checksum = "c152169ef1e421390738366d2f796655fec62621dabbd0fd476f905934061e4a"

476+checksum = "10463d9ff00a2a068db14231982f5132edebad0d7660cd956a1c30292dbcbfbd"

517477dependencies = [

518478 "aho-corasick",

519479 "bstr",

@@ -522,26 +482,43 @@ dependencies = [

522482 "regex",

523483]

524484

485+[[package]]

486+name = "grep-cli"

487+version = "0.1.6"

488+source = "registry+https://github.com/rust-lang/crates.io-index"

489+checksum = "2dd110c34bb4460d0de5062413b773e385cbf8a85a63fc535590110a09e79e8a"

490+dependencies = [

491+ "atty",

492+ "bstr",

493+ "globset",

494+ "lazy_static",

495+ "log",

496+ "regex",

497+ "same-file",

498+ "termcolor",

499+ "winapi-util",

500+]

501+

525502[[package]]

526503name = "hashbrown"

527−version = "0.9.1"

504+version = "0.11.2"

528505source = "registry+https://github.com/rust-lang/crates.io-index"

529−checksum = "d7afe4a420e3fe79967a00898cc1f4db7c8a49a9333a29f8a4bd76a253d5cd04"

506+checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"

530507

531508[[package]]

532509name = "hermit-abi"

533−version = "0.1.16"

510+version = "0.1.19"

534511source = "registry+https://github.com/rust-lang/crates.io-index"

535−checksum = "4c30f6d0bc6b00693347368a67d41b58f2fb851215ff1da49e90fe2c5c667151"

512+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"

536513dependencies = [

537514 "libc",

538515]

539516

540517[[package]]

541518name = "idna"

542−version = "0.2.0"

519+version = "0.2.3"

543520source = "registry+https://github.com/rust-lang/crates.io-index"

544−checksum = "02e2673c30ee86b5b96a9cb52ad15718aa1f966f5ab9ad54a8b95d5ca33120a9"

521+checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"

545522dependencies = [

546523 "matches",

547524 "unicode-bidi",

@@ -550,25 +527,49 @@ dependencies = [

550527

551528[[package]]

552529name = "indexmap"

553−version = "1.6.0"

530+version = "1.7.0"

554531source = "registry+https://github.com/rust-lang/crates.io-index"

555−checksum = "55e2e4c765aa53a0424761bf9f41aa7a6ac1efa87238f59560640e27fca028f2"

532+checksum = "bc633605454125dec4b66843673f01c7df2b89479b32e0ed634e43a91cff62a5"

556533dependencies = [

557534 "autocfg",

558535 "hashbrown",

559536]

560537

538+[[package]]

539+name = "instant"

540+version = "0.1.12"

541+source = "registry+https://github.com/rust-lang/crates.io-index"

542+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"

543+dependencies = [

544+ "cfg-if",

545+]

546+

547+[[package]]

548+name = "itertools"

549+version = "0.10.3"

550+source = "registry+https://github.com/rust-lang/crates.io-index"

551+checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"

552+dependencies = [

553+ "either",

554+]

555+

561556[[package]]

562557name = "itoa"

563−version = "0.4.6"

558+version = "0.4.8"

564559source = "registry+https://github.com/rust-lang/crates.io-index"

565−checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"

560+checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"

561+

562+[[package]]

563+name = "itoa"

564+version = "1.0.1"

565+source = "registry+https://github.com/rust-lang/crates.io-index"

566+checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"

566567

567568[[package]]

568569name = "jobserver"

569−version = "0.1.21"

570+version = "0.1.24"

570571source = "registry+https://github.com/rust-lang/crates.io-index"

571−checksum = "5c71313ebb9439f74b00d9d2dcec36440beaf57a6aa0623068441dd7cd81a7f2"

572+checksum = "af25a77299a7f711a01975c35a6a424eb6862092cc2d6c72c4ed6cbc56dfc1fa"

572573dependencies = [

573574 "libc",

574575]

@@ -579,23 +580,17 @@ version = "1.4.0"

579580source = "registry+https://github.com/rust-lang/crates.io-index"

580581checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

581582

582−[[package]]

583−name = "lazycell"

584−version = "1.3.0"

585−source = "registry+https://github.com/rust-lang/crates.io-index"

586−checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"

587−

588583[[package]]

589584name = "libc"

590−version = "0.2.78"

585+version = "0.2.125"

591586source = "registry+https://github.com/rust-lang/crates.io-index"

592−checksum = "aa7087f49d294270db4e1928fc110c976cd4b9e5a16348e0a1df09afa99e6c98"

587+checksum = "5916d2ae698f6de9bfb891ad7a8d65c09d232dc58cc4ac433c7da3b2fd84bc2b"

593588

594589[[package]]

595590name = "libgit2-sys"

596−version = "0.12.14+1.1.0"

591+version = "0.13.2+1.4.2"

597592source = "registry+https://github.com/rust-lang/crates.io-index"

598−checksum = "8f25af58e6495f7caf2919d08f212de550cfa3ed2f5e744988938ea292b9f549"

593+checksum = "3a42de9a51a5c12e00fc0e4ca6bc2ea43582fc6418488e8f615e905d886f258b"

599594dependencies = [

600595 "cc",

601596 "libc",

@@ -605,9 +600,9 @@ dependencies = [

605600

606601[[package]]

607602name = "libz-sys"

608−version = "1.1.2"

603+version = "1.1.3"

609604source = "registry+https://github.com/rust-lang/crates.io-index"

610−checksum = "602113192b08db8f38796c4e85c39e960c145965140e918018bcde1952429655"

605+checksum = "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66"

611606dependencies = [

612607 "cc",

613608 "libc",

@@ -626,45 +621,58 @@ dependencies = [

626621

627622[[package]]

628623name = "linked-hash-map"

629−version = "0.5.3"

624+version = "0.5.4"

630625source = "registry+https://github.com/rust-lang/crates.io-index"

631−checksum = "8dd5a6d5999d9907cda8ed67bbd137d3af8085216c2ac62de5be860bd41f304a"

626+checksum = "7fb9b38af92608140b86b693604b9ffcc5824240a484d1ecd4795bacb2fe88f3"

632627

633628[[package]]

634−name = "log"

635−version = "0.4.11"

629+name = "lock_api"

630+version = "0.4.5"

636631source = "registry+https://github.com/rust-lang/crates.io-index"

637−checksum = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b"

632+checksum = "712a4d093c9976e24e7dbca41db895dabcbac38eb5f4045393d17a95bdfb1109"

638633dependencies = [

639− "cfg-if",

634+ "scopeguard",

640635]

641636

642637[[package]]

643−name = "maplit"

644−version = "1.0.2"

638+name = "log"

639+version = "0.4.14"

645640source = "registry+https://github.com/rust-lang/crates.io-index"

646−checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"

641+checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"

642+dependencies = [

643+ "cfg-if",

644+]

647645

648646[[package]]

649647name = "matches"

650−version = "0.1.8"

648+version = "0.1.9"

651649source = "registry+https://github.com/rust-lang/crates.io-index"

652−checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"

650+checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"

653651

654652[[package]]

655653name = "memchr"

656−version = "2.3.3"

654+version = "2.4.1"

657655source = "registry+https://github.com/rust-lang/crates.io-index"

658−checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"

656+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"

659657

660658[[package]]

661659name = "miniz_oxide"

662−version = "0.4.2"

660+version = "0.5.1"

663661source = "registry+https://github.com/rust-lang/crates.io-index"

664−checksum = "c60c0dfe32c10b43a144bad8fc83538c52f58302c92300ea7ec7bf7b38d5a7b9"

662+checksum = "d2b29bd4bc3f33391105ebee3589c19197c4271e3e5a9ec9bfe8127eeff8f082"

665663dependencies = [

666664 "adler",

667− "autocfg",

665+]

666+

667+[[package]]

668+name = "nix"

669+version = "0.24.1"

670+source = "registry+https://github.com/rust-lang/crates.io-index"

671+checksum = "8f17df307904acd05aa8e32e97bb20f2a0df1728bbc2d771ae8f9a90463441e9"

672+dependencies = [

673+ "bitflags",

674+ "cfg-if",

675+ "libc",

668676]

669677

670678[[package]]

@@ -674,29 +682,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index"

674682checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"

675683

676684[[package]]

677−name = "num-integer"

678−version = "0.1.43"

685+name = "num-traits"

686+version = "0.2.14"

679687source = "registry+https://github.com/rust-lang/crates.io-index"

680−checksum = "8d59457e662d541ba17869cf51cf177c0b5f0cbf476c66bdc90bf1edac4f875b"

688+checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"

681689dependencies = [

682690 "autocfg",

683− "num-traits",

684691]

685692

686693[[package]]

687−name = "num-traits"

688−version = "0.2.12"

694+name = "once_cell"

695+version = "1.10.0"

689696source = "registry+https://github.com/rust-lang/crates.io-index"

690−checksum = "ac267bcc07f48ee5f8935ab0d24f316fb722d7a1292e2913f0cc196b29ffd611"

691−dependencies = [

692− "autocfg",

693−]

697+checksum = "87f3e037eac156d1775da914196f0f37741a274155e34a0b7e427c35d2a2ecb9"

694698

695699[[package]]

696700name = "onig"

697−version = "6.1.0"

701+version = "6.3.1"

698702source = "registry+https://github.com/rust-lang/crates.io-index"

699−checksum = "8a155d13862da85473665694f4c05d77fb96598bdceeaf696433c84ea9567e20"

703+checksum = "67ddfe2c93bb389eea6e6d713306880c7f6dcc99a75b659ce145d962c861b225"

700704dependencies = [

701705 "bitflags",

702706 "lazy_static",

@@ -706,106 +710,83 @@ dependencies = [

706710

707711[[package]]

708712name = "onig_sys"

709−version = "69.5.1"

713+version = "69.7.1"

710714source = "registry+https://github.com/rust-lang/crates.io-index"

711−checksum = "9bff06597a6b17855040955cae613af000fc0bfc8ad49ea68b9479a74e59292d"

715+checksum = "5dd3eee045c84695b53b20255bb7317063df090b68e18bfac0abb6c39cf7f33e"

712716dependencies = [

713717 "cc",

714718 "pkg-config",

715719]

716720

717721[[package]]

718−name = "opaque-debug"

719−version = "0.2.3"

722+name = "parking_lot"

723+version = "0.11.2"

720724source = "registry+https://github.com/rust-lang/crates.io-index"

721−checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"

722−

723−[[package]]

724−name = "path_abs"

725−version = "0.5.0"

726−source = "registry+https://github.com/rust-lang/crates.io-index"

727−checksum = "eb6b8e6dede0bf94e9300e669f335ba92d5fc9fc8be7f4b1ca8a05206489388c"

725+checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"

728726dependencies = [

729− "std_prelude",

727+ "instant",

728+ "lock_api",

729+ "parking_lot_core",

730730]

731731

732732[[package]]

733−name = "percent-encoding"

734−version = "2.1.0"

733+name = "parking_lot_core"

734+version = "0.8.5"

735735source = "registry+https://github.com/rust-lang/crates.io-index"

736−checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"

737−

738−[[package]]

739−name = "pest"

740−version = "2.1.3"

741−source = "registry+https://github.com/rust-lang/crates.io-index"

742−checksum = "10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53"

736+checksum = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216"

743737dependencies = [

744− "ucd-trie",

745−]

746−

747−[[package]]

748−name = "pest_derive"

749−version = "2.1.0"

750−source = "registry+https://github.com/rust-lang/crates.io-index"

751−checksum = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0"

752−dependencies = [

753− "pest",

754− "pest_generator",

738+ "cfg-if",

739+ "instant",

740+ "libc",

741+ "redox_syscall",

742+ "smallvec",

743+ "winapi",

755744]

756745

757746[[package]]

758−name = "pest_generator"

759−version = "2.1.3"

747+name = "path_abs"

748+version = "0.5.1"

760749source = "registry+https://github.com/rust-lang/crates.io-index"

761−checksum = "99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55"

750+checksum = "05ef02f6342ac01d8a93b65f96db53fe68a92a15f41144f97fb00a9e669633c3"

762751dependencies = [

763− "pest",

764− "pest_meta",

765− "proc-macro2",

766− "quote",

767− "syn",

752+ "std_prelude",

768753]

769754

770755[[package]]

771−name = "pest_meta"

772−version = "2.1.3"

756+name = "percent-encoding"

757+version = "2.1.0"

773758source = "registry+https://github.com/rust-lang/crates.io-index"

774−checksum = "54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d"

775−dependencies = [

776− "maplit",

777− "pest",

778− "sha-1",

779−]

759+checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"

780760

781761[[package]]

782762name = "pkg-config"

783−version = "0.3.18"

763+version = "0.3.24"

784764source = "registry+https://github.com/rust-lang/crates.io-index"

785−checksum = "d36492546b6af1463394d46f0c834346f31548646f6ba10849802c9c9a27ac33"

765+checksum = "58893f751c9b0412871a09abd62ecd2a00298c6c83befa223ef98c52aef40cbe"

786766

787767[[package]]

788768name = "plist"

789−version = "1.0.0"

769+version = "1.3.1"

790770source = "registry+https://github.com/rust-lang/crates.io-index"

791−checksum = "7b336d94e8e4ce29bf15bba393164629764744c567e8ad306cc1fdd0119967fd"

771+checksum = "bd39bc6cdc9355ad1dc5eeedefee696bb35c34caf21768741e81826c0bbd7225"

792772dependencies = [

793773 "base64",

794− "chrono",

795774 "indexmap",

796775 "line-wrap",

797776 "serde",

777+ "time",

798778 "xml-rs",

799779]

800780

801781[[package]]

802782name = "predicates"

803−version = "1.0.5"

783+version = "2.1.1"

804784source = "registry+https://github.com/rust-lang/crates.io-index"

805−checksum = "96bfead12e90dccead362d62bb2c90a5f6fc4584963645bc7f71a735e0b0735a"

785+checksum = "a5aab5be6e4732b473071984b3164dbbfb7a3674d30ea5ff44410b6bcd960c3c"

806786dependencies = [

807− "difference",

787+ "difflib",

808788 "float-cmp",

789+ "itertools",

809790 "normalize-line-endings",

810791 "predicates-core",

811792 "regex",

@@ -813,109 +794,109 @@ dependencies = [

813794

814795[[package]]

815796name = "predicates-core"

816−version = "1.0.0"

797+version = "1.0.2"

817798source = "registry+https://github.com/rust-lang/crates.io-index"

818−checksum = "06075c3a3e92559ff8929e7a280684489ea27fe44805174c3ebd9328dcb37178"

799+checksum = "57e35a3326b75e49aa85f5dc6ec15b41108cf5aee58eabb1f274dd18b73c2451"

819800

820801[[package]]

821802name = "predicates-tree"

822−version = "1.0.0"

803+version = "1.0.4"

823804source = "registry+https://github.com/rust-lang/crates.io-index"

824−checksum = "8e63c4859013b38a76eca2414c64911fba30def9e3202ac461a2d22831220124"

805+checksum = "338c7be2905b732ae3984a2f40032b5e94fd8f52505b186c7d4d68d193445df7"

825806dependencies = [

826807 "predicates-core",

827− "treeline",

808+ "termtree",

828809]

829810

830811[[package]]

831−name = "proc-macro2"

832−version = "1.0.24"

812+name = "proc-macro-error"

813+version = "1.0.4"

833814source = "registry+https://github.com/rust-lang/crates.io-index"

834−checksum = "1e0704ee1a7e00d7bb417d0770ea303c1bccbabf0ef1667dae92b5967f5f8a71"

815+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"

835816dependencies = [

836− "unicode-xid",

817+ "proc-macro-error-attr",

818+ "proc-macro2",

819+ "quote",

820+ "syn",

821+ "version_check",

837822]

838823

839824[[package]]

840−name = "quote"

841−version = "1.0.7"

825+name = "proc-macro-error-attr"

826+version = "1.0.4"

842827source = "registry+https://github.com/rust-lang/crates.io-index"

843−checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"

828+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"

844829dependencies = [

845830 "proc-macro2",

831+ "quote",

832+ "version_check",

846833]

847834

848835[[package]]

849−name = "rand"

850−version = "0.4.6"

836+name = "proc-macro-hack"

837+version = "0.5.19"

851838source = "registry+https://github.com/rust-lang/crates.io-index"

852−checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293"

853−dependencies = [

854− "fuchsia-cprng",

855− "libc",

856− "rand_core 0.3.1",

857− "rdrand",

858− "winapi",

859−]

839+checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"

860840

861841[[package]]

862−name = "rand_core"

863−version = "0.3.1"

842+name = "proc-macro2"

843+version = "1.0.36"

864844source = "registry+https://github.com/rust-lang/crates.io-index"

865−checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"

845+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"

866846dependencies = [

867− "rand_core 0.4.2",

847+ "unicode-xid",

868848]

869849

870850[[package]]

871−name = "rand_core"

872−version = "0.4.2"

873−source = "registry+https://github.com/rust-lang/crates.io-index"

874−checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"

875−

876−[[package]]

877−name = "rdrand"

878−version = "0.4.0"

851+name = "quote"

852+version = "1.0.14"

879853source = "registry+https://github.com/rust-lang/crates.io-index"

880−checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"

854+checksum = "47aa80447ce4daf1717500037052af176af5d38cc3e571d9ec1c7353fc10c87d"

881855dependencies = [

882− "rand_core 0.3.1",

856+ "proc-macro2",

883857]

884858

885859[[package]]

886860name = "redox_syscall"

887−version = "0.1.57"

861+version = "0.2.10"

888862source = "registry+https://github.com/rust-lang/crates.io-index"

889−checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"

863+checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"

864+dependencies = [

865+ "bitflags",

866+]

890867

891868[[package]]

892869name = "redox_users"

893−version = "0.3.5"

870+version = "0.4.0"

894871source = "registry+https://github.com/rust-lang/crates.io-index"

895−checksum = "de0737333e7a9502c789a36d7c7fa6092a49895d4faa31ca5df163857ded2e9d"

872+checksum = "528532f3d801c87aec9def2add9ca802fe569e44a544afe633765267840abe64"

896873dependencies = [

897874 "getrandom",

898875 "redox_syscall",

899− "rust-argon2",

900876]

901877

902878[[package]]

903879name = "regex"

904−version = "1.3.9"

880+version = "1.5.5"

905881source = "registry+https://github.com/rust-lang/crates.io-index"

906−checksum = "9c3780fcf44b193bc4d09f36d2a3c87b251da4a046c87795a0d35f4f927ad8e6"

882+checksum = "1a11647b6b25ff05a515cb92c365cec08801e83423a235b51e231e1808747286"

907883dependencies = [

908884 "aho-corasick",

909885 "memchr",

910886 "regex-syntax",

911− "thread_local",

912887]

913888

889+[[package]]

890+name = "regex-automata"

891+version = "0.1.10"

892+source = "registry+https://github.com/rust-lang/crates.io-index"

893+checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"

894+

914895[[package]]

915896name = "regex-syntax"

916−version = "0.6.18"

897+version = "0.6.25"

917898source = "registry+https://github.com/rust-lang/crates.io-index"

918−checksum = "26412eb97c6b088a6997e05f69403a802a92d520de2f8e63c2b65f9e0f47c4e8"

899+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"

919900

920901[[package]]

921902name = "remove_dir_all"

@@ -927,22 +908,25 @@ dependencies = [

927908]

928909

929910[[package]]

930−name = "rust-argon2"

931−version = "0.8.2"

911+name = "rgb"

912+version = "0.8.31"

932913source = "registry+https://github.com/rust-lang/crates.io-index"

933−checksum = "9dab61250775933275e84053ac235621dfb739556d5c54a2f2e9313b7cf43a19"

914+checksum = "9a374af9a0e5fdcdd98c1c7b64f05004f9ea2555b6c75f211daa81268a3c50f1"

934915dependencies = [

935− "base64",

936− "blake2b_simd",

937− "constant_time_eq",

938− "crossbeam-utils",

916+ "bytemuck",

939917]

940918

919+[[package]]

920+name = "rustversion"

921+version = "1.0.6"

922+source = "registry+https://github.com/rust-lang/crates.io-index"

923+checksum = "f2cc38e8fa666e2de3c4aba7edeb5ffc5246c1c2ed0e3d17e560aeeba736b23f"

924+

941925[[package]]

942926name = "ryu"

943−version = "1.0.5"

927+version = "1.0.9"

944928source = "registry+https://github.com/rust-lang/crates.io-index"

945−checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"

929+checksum = "73b4b750c782965c211b42f022f59af1fbceabdd026623714f104152f1ec149f"

946930

947931[[package]]

948932name = "safemem"

@@ -960,38 +944,31 @@ dependencies = [

960944]

961945

962946[[package]]

963−name = "semver"

964−version = "0.11.0"

947+name = "scopeguard"

948+version = "1.1.0"

965949source = "registry+https://github.com/rust-lang/crates.io-index"

966−checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"

967−dependencies = [

968− "semver-parser",

969−]

950+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"

970951

971952[[package]]

972−name = "semver-parser"

973−version = "0.10.0"

953+name = "semver"

954+version = "1.0.7"

974955source = "registry+https://github.com/rust-lang/crates.io-index"

975−checksum = "0e012c6c5380fb91897ba7b9261a0f565e624e869d42fe1a1d03fa0d68a083d5"

976−dependencies = [

977− "pest",

978− "pest_derive",

979−]

956+checksum = "d65bd28f48be7196d222d95b9243287f48d27aca604e08497513019ff0502cc4"

980957

981958[[package]]

982959name = "serde"

983−version = "1.0.117"

960+version = "1.0.136"

984961source = "registry+https://github.com/rust-lang/crates.io-index"

985−checksum = "b88fa983de7720629c9387e9f517353ed404164b1e482c970a90c1a4aaf7dc1a"

962+checksum = "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789"

986963dependencies = [

987964 "serde_derive",

988965]

989966

990967[[package]]

991968name = "serde_derive"

992−version = "1.0.117"

969+version = "1.0.136"

993970source = "registry+https://github.com/rust-lang/crates.io-index"

994−checksum = "cbd1ae72adb44aab48f325a02444a5fc079349a8d804c1fc922aed3f7454c74e"

971+checksum = "08597e7152fcd306f41838ed3e37be9eaeed2b61c42e2117266a554fab4662f9"

995972dependencies = [

996973 "proc-macro2",

997974 "quote",

@@ -1000,44 +977,68 @@ dependencies = [

1000977

1001978[[package]]

1002979name = "serde_json"

1003−version = "1.0.58"

980+version = "1.0.74"

1004981source = "registry+https://github.com/rust-lang/crates.io-index"

1005−checksum = "a230ea9107ca2220eea9d46de97eddcb04cd00e92d13dda78e478dd33fa82bd4"

982+checksum = "ee2bb9cd061c5865d345bb02ca49fcef1391741b672b54a0bf7b679badec3142"

1006983dependencies = [

1007− "itoa",

984+ "itoa 1.0.1",

1008985 "ryu",

1009986 "serde",

1010987]

1011988

1012989[[package]]

1013990name = "serde_yaml"

1014−version = "0.8.14"

991+version = "0.8.23"

1015992source = "registry+https://github.com/rust-lang/crates.io-index"

1016−checksum = "f7baae0a99f1a324984bcdc5f0718384c1f69775f1c7eec8b859b71b443e3fd7"

993+checksum = "a4a521f2940385c165a24ee286aa8599633d162077a54bdcae2a6fd5a7bfa7a0"

1017994dependencies = [

1018− "dtoa",

1019− "linked-hash-map",

995+ "indexmap",

996+ "ryu",

1020997 "serde",

1021998 "yaml-rust",

1022999]

10231000

10241001[[package]]

1025−name = "sha-1"

1026−version = "0.8.2"

1002+name = "serial_test"

1003+version = "0.6.0"

10271004source = "registry+https://github.com/rust-lang/crates.io-index"

1028−checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"

1005+checksum = "e5bcc41d18f7a1d50525d080fd3e953be87c4f9f1a974f3c21798ca00d54ec15"

10291006dependencies = [

1030− "block-buffer",

1031− "digest",

1032− "fake-simd",

1033− "opaque-debug",

1007+ "lazy_static",

1008+ "parking_lot",

1009+ "serial_test_derive",

10341010]

10351011

1012+[[package]]

1013+name = "serial_test_derive"

1014+version = "0.6.0"

1015+source = "registry+https://github.com/rust-lang/crates.io-index"

1016+checksum = "2881bccd7d60fb32dfa3d7b3136385312f8ad75e2674aab2852867a09790cae8"

1017+dependencies = [

1018+ "proc-macro-error",

1019+ "proc-macro2",

1020+ "quote",

1021+ "rustversion",

1022+ "syn",

1023+]

1024+

1025+[[package]]

1026+name = "shell-escape"

1027+version = "0.1.5"

1028+source = "registry+https://github.com/rust-lang/crates.io-index"

1029+checksum = "45bb67a18fa91266cc7807181f62f9178a6873bfad7dc788c42e6430db40184f"

1030+

10361031[[package]]

10371032name = "shell-words"

1038−version = "1.0.0"

1033+version = "1.1.0"

1034+source = "registry+https://github.com/rust-lang/crates.io-index"

1035+checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"

1036+

1037+[[package]]

1038+name = "smallvec"

1039+version = "1.7.0"

10391040source = "registry+https://github.com/rust-lang/crates.io-index"

1040−checksum = "b6fa3938c99da4914afedd13bf3d79bcb6c277d1b2c398d23257a304d9e1b074"

1041+checksum = "1ecab6c735a6bb4139c0caafd0cc3635748bbb3acf4550e8138122099251f309"

10411042

10421043[[package]]

10431044name = "std_prelude"

@@ -1053,9 +1054,9 @@ checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"

10531054

10541055[[package]]

10551056name = "syn"

1056−version = "1.0.42"

1057+version = "1.0.85"

10571058source = "registry+https://github.com/rust-lang/crates.io-index"

1058−checksum = "9c51d92969d209b54a98397e1b91c8ae82d8c87a7bb87df0b29aa2ad81454228"

1059+checksum = "a684ac3dcd8913827e18cd09a68384ee66c1de24157e3c556c9ab16d85695fb7"

10591060dependencies = [

10601061 "proc-macro2",

10611062 "quote",

@@ -1064,9 +1065,9 @@ dependencies = [

10641065

10651066[[package]]

10661067name = "syntect"

1067−version = "4.4.0"

1068+version = "5.0.0"

10681069source = "registry+https://github.com/rust-lang/crates.io-index"

1069−checksum = "4e3978df05b5850c839a6b352d3c35ce0478944a4be689be826b53cf75363e88"

1070+checksum = "c6c454c27d9d7d9a84c7803aaa3c50cd088d2906fe3c6e42da3209aa623576a8"

10701071dependencies = [

10711072 "bincode",

10721073 "bitflags",

@@ -1074,25 +1075,40 @@ dependencies = [

10741075 "flate2",

10751076 "fnv",

10761077 "lazy_static",

1077− "lazycell",

1078+ "once_cell",

10781079 "onig",

10791080 "plist",

10801081 "regex-syntax",

10811082 "serde",

10821083 "serde_derive",

10831084 "serde_json",

1085+ "thiserror",

10841086 "walkdir",

10851087 "yaml-rust",

10861088]

10871089

10881090[[package]]

1089−name = "tempdir"

1090−version = "0.3.7"

1091+name = "sys-info"

1092+version = "0.9.1"

1093+source = "registry+https://github.com/rust-lang/crates.io-index"

1094+checksum = "0b3a0d0aba8bf96a0e1ddfdc352fc53b3df7f39318c71854910c3c4b024ae52c"

1095+dependencies = [

1096+ "cc",

1097+ "libc",

1098+]

1099+

1100+[[package]]

1101+name = "tempfile"

1102+version = "3.3.0"

10911103source = "registry+https://github.com/rust-lang/crates.io-index"

1092−checksum = "15f2b5fb00ccdf689e0149d1b1b3c03fead81c2b37735d812fa8bddbbf41b6d8"

1104+checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"

10931105dependencies = [

1094− "rand",

1106+ "cfg-if",

1107+ "fastrand",

1108+ "libc",

1109+ "redox_syscall",

10951110 "remove_dir_all",

1111+ "winapi",

10961112]

10971113

10981114[[package]]

@@ -1105,16 +1121,31 @@ dependencies = [

11051121 "winapi",

11061122]

11071123

1124+[[package]]

1125+name = "termcolor"

1126+version = "1.1.2"

1127+source = "registry+https://github.com/rust-lang/crates.io-index"

1128+checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"

1129+dependencies = [

1130+ "winapi-util",

1131+]

1132+

11081133[[package]]

11091134name = "terminal_size"

1110−version = "0.1.13"

1135+version = "0.1.17"

11111136source = "registry+https://github.com/rust-lang/crates.io-index"

1112−checksum = "9a14cd9f8c72704232f0bfc8455c0e861f0ad4eb60cc9ec8a170e231414c1e13"

1137+checksum = "633c1a546cee861a1a6d0dc69ebeca693bf4296661ba7852b9d21d159e0506df"

11131138dependencies = [

11141139 "libc",

11151140 "winapi",

11161141]

11171142

1143+[[package]]

1144+name = "termtree"

1145+version = "0.2.3"

1146+source = "registry+https://github.com/rust-lang/crates.io-index"

1147+checksum = "13a4ec180a2de59b57434704ccfad967f789b12737738798fa08798cd5824c16"

1148+

11181149[[package]]

11191150name = "textwrap"

11201151version = "0.11.0"

@@ -1126,74 +1157,84 @@ dependencies = [

11261157]

11271158

11281159[[package]]

1129−name = "thread_local"

1130−version = "1.0.1"

1160+name = "thiserror"

1161+version = "1.0.31"

11311162source = "registry+https://github.com/rust-lang/crates.io-index"

1132−checksum = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"

1163+checksum = "bd829fe32373d27f76265620b5309d0340cb8550f523c1dda251d6298069069a"

11331164dependencies = [

1134− "lazy_static",

1165+ "thiserror-impl",

11351166]

11361167

11371168[[package]]

1138−name = "tinyvec"

1139−version = "0.3.4"

1169+name = "thiserror-impl"

1170+version = "1.0.31"

11401171source = "registry+https://github.com/rust-lang/crates.io-index"

1141−checksum = "238ce071d267c5710f9d31451efec16c5ee22de34df17cc05e56cbc92e967117"

1172+checksum = "0396bc89e626244658bef819e22d0cc459e795a5ebe878e6ec336d1674a8d79a"

1173+dependencies = [

1174+ "proc-macro2",

1175+ "quote",

1176+ "syn",

1177+]

11421178

11431179[[package]]

1144−name = "treeline"

1145−version = "0.1.0"

1180+name = "time"

1181+version = "0.3.5"

11461182source = "registry+https://github.com/rust-lang/crates.io-index"

1147−checksum = "a7f741b240f1a48843f9b8e0444fb55fb2a4ff67293b50a9179dfd5ea67f8d41"

1183+checksum = "41effe7cfa8af36f439fac33861b66b049edc6f9a32331e2312660529c1c24ad"

1184+dependencies = [

1185+ "itoa 0.4.8",

1186+ "libc",

1187+]

11481188

11491189[[package]]

1150−name = "typenum"

1151−version = "1.12.0"

1190+name = "tinyvec"

1191+version = "1.5.1"

11521192source = "registry+https://github.com/rust-lang/crates.io-index"

1153−checksum = "373c8a200f9e67a0c95e62a4f52fbf80c23b4381c05a17845531982fa99e6b33"

1193+checksum = "2c1c1d5a42b6245520c249549ec267180beaffcc0615401ac8e31853d4b6d8d2"

1194+dependencies = [

1195+ "tinyvec_macros",

1196+]

11541197

11551198[[package]]

1156−name = "ucd-trie"

1157−version = "0.1.3"

1199+name = "tinyvec_macros"

1200+version = "0.1.0"

11581201source = "registry+https://github.com/rust-lang/crates.io-index"

1159−checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"

1202+checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"

11601203

11611204[[package]]

11621205name = "unicode-bidi"

1163−version = "0.3.4"

1206+version = "0.3.7"

11641207source = "registry+https://github.com/rust-lang/crates.io-index"

1165−checksum = "49f2bd0c6468a8230e1db229cff8029217cf623c767ea5d60bfbd42729ea54d5"

1166−dependencies = [

1167− "matches",

1168−]

1208+checksum = "1a01404663e3db436ed2746d9fefef640d868edae3cceb81c3b8d5732fda678f"

11691209

11701210[[package]]

11711211name = "unicode-normalization"

1172−version = "0.1.13"

1212+version = "0.1.19"

11731213source = "registry+https://github.com/rust-lang/crates.io-index"

1174−checksum = "6fb19cf769fa8c6a80a162df694621ebeb4dafb606470b2b2fce0be40a98a977"

1214+checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"

11751215dependencies = [

11761216 "tinyvec",

11771217]

11781218

11791219[[package]]

11801220name = "unicode-width"

1181−version = "0.1.8"

1221+version = "0.1.9"

11821222source = "registry+https://github.com/rust-lang/crates.io-index"

1183−checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"

1223+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"

11841224

11851225[[package]]

11861226name = "unicode-xid"

1187−version = "0.2.1"

1227+version = "0.2.2"

11881228source = "registry+https://github.com/rust-lang/crates.io-index"

1189−checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"

1229+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"

11901230

11911231[[package]]

11921232name = "url"

1193−version = "2.1.1"

1233+version = "2.2.2"

11941234source = "registry+https://github.com/rust-lang/crates.io-index"

1195−checksum = "829d4a8476c35c9bf0bbce5a3b23f4106f79728039b726d292bb93bc106787cb"

1235+checksum = "a507c383b2d33b5fc35d1861e77e6b383d158b2da5e14fe51b83dfedf6fd578c"

11961236dependencies = [

1237+ "form_urlencoded",

11971238 "idna",

11981239 "matches",

11991240 "percent-encoding",

@@ -1201,9 +1242,9 @@ dependencies = [

12011242

12021243[[package]]

12031244name = "vcpkg"

1204−version = "0.2.10"

1245+version = "0.2.15"

12051246source = "registry+https://github.com/rust-lang/crates.io-index"

1206−checksum = "6454029bf181f092ad1b853286f23e2c507d8e8194d01d92da4a55c274a5508c"

1247+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"

12071248

12081249[[package]]

12091250name = "vec_map"

@@ -1213,9 +1254,9 @@ checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"

12131254

12141255[[package]]

12151256name = "version_check"

1216−version = "0.9.2"

1257+version = "0.9.4"

12171258source = "registry+https://github.com/rust-lang/crates.io-index"

1218−checksum = "b5a972e5669d67ba988ce3dc826706fb0a8b01471c088cb0b6110b805cc36aed"

1259+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"

12191260

12201261[[package]]

12211262name = "wait-timeout"

@@ -1228,9 +1269,9 @@ dependencies = [

12281269

12291270[[package]]

12301271name = "walkdir"

1231−version = "2.3.1"

1272+version = "2.3.2"

12321273source = "registry+https://github.com/rust-lang/crates.io-index"

1233−checksum = "777182bc735b6424e1a57516d35ed72cb8019d85c8c9bf536dccb3445c1a2f7d"

1274+checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"

12341275dependencies = [

12351276 "same-file",

12361277 "winapi",

@@ -1239,9 +1280,9 @@ dependencies = [

12391280

12401281[[package]]

12411282name = "wasi"

1242−version = "0.9.0+wasi-snapshot-preview1"

1283+version = "0.10.2+wasi-snapshot-preview1"

12431284source = "registry+https://github.com/rust-lang/crates.io-index"

1244−checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"

1285+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"

12451286

12461287[[package]]

12471288name = "wild"

@@ -1285,15 +1326,15 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

12851326

12861327[[package]]

12871328name = "xml-rs"

1288−version = "0.8.3"

1329+version = "0.8.4"

12891330source = "registry+https://github.com/rust-lang/crates.io-index"

1290−checksum = "b07db065a5cf61a7e4ba64f29e67db906fb1787316516c4e6e5ff0fea1efcd8a"

1331+checksum = "d2d7d3948613f75c98fd9328cfdcc45acc4d360655289d0a7d4ec931392200a3"

12911332

12921333[[package]]

12931334name = "yaml-rust"

1294−version = "0.4.4"

1335+version = "0.4.5"

12951336source = "registry+https://github.com/rust-lang/crates.io-index"

1296−checksum = "39f0c922f1a334134dc2f7a8b67dc5d25f0735263feec974345ff706bcf20b0d"

1337+checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"

12971338dependencies = [

12981339 "linked-hash-map",

12991340]

Cargo.toml+46−31

@@ -1,17 +1,13 @@

11[package]

22authors = ["David Peter <mail@david-peter.de>"]

33categories = ["command-line-utilities"]

4−description="A cat(1) clone with wings."

4+description = "A cat(1) clone with wings."

55homepage = "https://github.com/sharkdp/bat"

66license = "MIT/Apache-2.0"

77name = "bat"

8−readme = "README.md"

98repository = "https://github.com/sharkdp/bat"

10−version = "0.17.1"

11−exclude = [

12− "assets/syntaxes/*",

13− "assets/themes/*",

14−]

9+version = "0.21.0"

10+exclude = ["assets/syntaxes/*", "assets/themes/*"]

1511build = "build.rs"

1612edition = '2018'

1713

@@ -20,65 +16,84 @@ default = ["application"]

2016# Feature required for bat the application. Should be disabled when depending on

2117# bat as a library.

2218application = [

19+ "bugreport",

20+ "build-assets",

21+ "git",

22+ "minimal-application",

23+]

24+# Mainly for developers that want to iterate quickly

25+# Be aware that the included features might change in the future

26+minimal-application = [

2327 "atty",

2428 "clap",

25− "dirs",

26− "git",

27− "lazy_static",

29+ "dirs-next",

2830 "paging",

29− "wild",

3031 "regex-onig",

32+ "wild",

3133]

3234git = ["git2"] # Support indicating git modifications

33−paging = ["shell-words"] # Support applying a pager on the output

35+paging = ["shell-words", "grep-cli"] # Support applying a pager on the output

36+build-assets = ["syntect/yaml-load", "syntect/plist-load", "regex", "walkdir"]

37+

38+# You need to use one of these if you depend on bat as a library:

3439regex-onig = ["syntect/regex-onig"] # Use the "oniguruma" regex engine

3540regex-fancy = ["syntect/regex-fancy"] # Use the rust-only "fancy-regex" engine

3641

3742[dependencies]

3843atty = { version = "0.2.14", optional = true }

3944ansi_term = "^0.12.1"

40−ansi_colours = "^1.0"

41−console = "0.13.0"

42−dirs = { version = "3.0", optional = true }

43−lazy_static = { version = "1.4", optional = true }

45+ansi_colours = "^1.1"

46+bincode = "1.0"

47+console = "0.15.0"

48+flate2 = "1.0"

49+once_cell = "1.10"

50+thiserror = "1.0"

4451wild = { version = "2.0", optional = true }

4552content_inspector = "0.2.4"

4653encoding = "0.2"

47−shell-words = { version = "1.0.0", optional = true }

48−unicode-width = "0.1.8"

54+shell-words = { version = "1.1.0", optional = true }

55+unicode-width = "0.1.9"

4956globset = "0.4"

5057serde = { version = "1.0", features = ["derive"] }

5158serde_yaml = "0.8"

52−semver = "0.11"

59+semver = "1.0"

5360path_abs = { version = "0.5", default-features = false }

61+clircle = "0.3"

62+bugreport = { version = "0.5.0", optional = true }

63+dirs-next = { version = "2.0.0", optional = true }

64+grep-cli = { version = "0.1.6", optional = true }

65+regex = { version = "1.5.5", optional = true }

66+walkdir = { version = "2.0", optional = true }

67+bytesize = { version = "1.1.0" }

5468

5569[dependencies.git2]

56−version = "0.13"

70+version = "0.14"

5771optional = true

5872default-features = false

5973

6074[dependencies.syntect]

61−version = "4.4.0"

75+version = "5.0.0"

6276default-features = false

63−features = ["parsing", "yaml-load", "dump-load", "dump-create"]

77+features = ["parsing"]

6478

6579[dependencies.clap]

66−version = "2.33"

80+version = "2.34"

6781optional = true

6882default-features = false

6983features = ["suggestions", "color", "wrap_help"]

7084

71−[dependencies.error-chain]

72−version = "0.12"

73−default-features = false

74−

7585[dev-dependencies]

76−tempdir = "0.3"

77−assert_cmd = "1.0.2"

78−predicates = "1.0.5"

86+assert_cmd = "2.0.4"

87+serial_test = "0.6.0"

88+predicates = "2.1.1"

89+wait-timeout = "0.2.0"

90+tempfile = "3.3.0"

91+

92+[target.'cfg(unix)'.dev-dependencies]

93+nix = { version = "0.24.1", default-features = false, features = ["term"] }

7994

8095[build-dependencies]

81−clap = { version = "2.33", optional = true }

96+clap = { version = "2.34", optional = true }

8297

8398[profile.release]

8499lto = true

LICENSE-MIT+1−1

@@ -1,4 +1,4 @@

33Permission is hereby granted, free of charge, to any person obtaining a copy

44of this software and associated documentation files (the "Software"), to deal

NOTICEnew file+6

@@ -0,0 +1,6 @@

3+bat is made available under the terms of either the MIT License or the Apache

4+License 2.0, at your option.

6+See the LICENSE-APACHE and LICENSE-MIT files for license details.

README.md+114−32

@@ -12,9 +12,26 @@

1212 <a href="#installation">Installation</a> •

1313 <a href="#customization">Customization</a> •

1414 <a href="#project-goals-and-alternatives">Project goals, alternatives</a>

15− [<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>]

15+ [English]

16+ [<a href="doc/README-zh.md">中文</a>]

17+ [<a href="doc/README-ja.md">日本語</a>]

18+ [<a href="doc/README-ko.md">한국어</a>]

19+ [<a href="doc/README-ru.md">Русский</a>]

1620

1721

22+### Sponsors

23+

24+A special *thank you* goes to our biggest <a href="doc/sponsors.md">sponsors</a>:

25+<a href="https://workos.com/?utm_campaign=github_repo&utm_medium=referral&utm_content=bat&utm_source=github">

26+ <img src="doc/sponsors/workos-logo-white-bg.svg" width="200" alt="WorkOS">

27+

28+ Your app, enterprise-ready.

29+

30+ Start selling to enterprise customers with just a few lines of code.

31+

32+ Add Single Sign-On (and more) in minutes instead of months.

33+</a>

34+

1835### Syntax highlighting

1936

2037`bat` supports syntax highlighting for a large number of programming and markup

@@ -38,7 +55,7 @@ characters:

3855

3956### Automatic paging

4057

41−By default, `bat` pipes its own output to a pager (e.g `less`) if the output is too large for one screen.

58+By default, `bat` pipes its own output to a pager (e.g. `less`) if the output is too large for one screen.

4259If 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.

4360If you intend to alias `cat` to `bat` in your shell configuration, you can use `alias cat='bat --paging=never'` to preserve the default behavior.

4461

@@ -94,14 +111,28 @@ bat f - g # output 'f', then stdin, then 'g'.

94111

95112### Integration with other tools

96113

114+#### `fzf`

115+

116+You can use `bat` as a previewer for [`fzf`](https://github.com/junegunn/fzf). To do this,

117+use `bat`s `--color=always` option to force colorized output. You can also use `--line-range`

118+option to restrict the load times for long files:

119+

120+```bash

121+fzf --preview 'bat --color=always --style=numbers --line-range=:500 {}'

122+```

123+

124+For more information, see [`fzf`'s `README`](https://github.com/junegunn/fzf#preview-window).

125+

97126#### `find` or `fd`

98127

99128You can use the `-exec` option of `find` to preview all search results with `bat`:

129+

100130```bash

101131find … -exec bat {} +

102132```

103133

104134If you happen to use [`fd`](https://github.com/sharkdp/fd), you can use the `-X`/`--exec-batch` option to do the same:

135+

105136```bash

106137fd … -X bat

107138```

@@ -117,9 +148,11 @@ batgrep needle src/

117148#### `tail -f`

118149

119150`bat` can be combined with `tail -f` to continuously monitor a given file with syntax highlighting.

151+

120152```bash

121153tail -f /var/log/pacman.log | bat --paging=never -l log

122154```

155+

123156Note that we have to switch off paging in order for this to work. We have also specified the syntax

124157explicitly (`-l log`), as it can not be auto-detected in this case.

125158

@@ -127,6 +160,7 @@ explicitly (`-l log`), as it can not be auto-detected in this case.

127160

128161You can combine `bat` with `git show` to view an older version of a given file with proper syntax

129162highlighting:

163+

130164```bash

131165git show v0.6.0:src/main.rs | bat -l rs

132166```

@@ -137,7 +171,7 @@ You can combine `bat` with `git diff` to view lines around code changes with pro

137171highlighting:

138172```bash

139173batdiff() {

140− git diff --name-only --diff-filter=d | xargs bat --diff

174+ git diff --name-only --relative --diff-filter=d | xargs bat --diff

141175}

142176```

143177If you prefer to use this as a separate tool, check out `batdiff` in [`bat-extras`](https://github.com/eth-p/bat-extras).

@@ -163,6 +197,7 @@ bat main.cpp | xclip

163197export MANPAGER="sh -c 'col -bx | bat -l man -p'"

164198man 2 select

165199```

200+(replace `bat` with `batcat` if you are on Debian or Ubuntu)

166201

167202It might also be necessary to set `MANROFFOPT="-c"` if you experience

168203formatting problems.

@@ -177,26 +212,41 @@ Also, note that this will [not work](https://github.com/sharkdp/bat/issues/1145)

177212

178213The [`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`.

179214

215+#### Highlighting `--help` messages

216+

217+You can use `bat` to colorize help text: `$ cp --help | bat -plhelp`

218+

219+You can also use a wrapper around this:

220+

221+```bash

222+# in your .bashrc/.zshrc/*rc

223+alias bathelp='bat --plain --language=help'

224+help() {

225+ "$@" --help 2>&1 | bathelp

226+}

227+```

228+

229+Then you can do `$ help cp` or `$ help git commit`.

230+

231+Please report any issues with the help syntax in [this repository](https://github.com/victor-gp/cmd-help-sublime-syntax).

232+

180233

181234## Installation

182235

183−[![Packaging status](https://repology.org/badge/vertical-allrepos/bat.svg)](https://repology.org/project/bat/versions)

236+[![Packaging status](https://repology.org/badge/vertical-allrepos/bat-cat.svg)](https://repology.org/project/bat-cat/versions)

184237

185238### On Ubuntu (using `apt`)

186239*... and other Debian-based Linux distributions.*

187240

188−`bat` is making its way through the [Ubuntu](https://packages.ubuntu.com/eoan/bat) and

189−[Debian](https://packages.debian.org/sid/bat) package release process, and is available

190−for Ubuntu as of Eoan 19.10. On Debian `bat` is currently only available on the unstable

191−"Sid" branch.

241+`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).

192242

193243If your Ubuntu/Debian installation is new enough you can simply run:

194244

195245```bash

196−apt install bat

246+sudo apt install bat

197247```

198248

199−If you install `bat` this way, please note that the executable may be installed as `batcat` instead of `bat` (due to [a name

249+**Important**: If you install `bat` this way, please note that the executable may be installed as `batcat` instead of `bat` (due to [a name

200250clash with another package](https://github.com/sharkdp/bat/issues/982)). You can set up a `bat -> batcat` symlink or alias to prevent any issues that may come up because of this and to be consistent with other distributions:

201251``` bash

202252mkdir -p ~/.local/bin

@@ -211,7 +261,7 @@ the most recent release of `bat`, download the latest `.deb` package from the

211261[release page](https://github.com/sharkdp/bat/releases) and install it via:

212262

213263```bash

214−sudo dpkg -i bat_0.17.1_amd64.deb # adapt version number and architecture

264+sudo dpkg -i bat_0.18.3_amd64.deb # adapt version number and architecture

215265```

216266

217267### On Alpine Linux

@@ -240,6 +290,14 @@ You can install [the `bat` package](https://koji.fedoraproject.org/koji/packagei

240290dnf install bat

241291```

242292

293+### On Funtoo Linux

294+

295+You can install [the `bat` package](https://github.com/funtoo/dev-kit/tree/1.4-release/sys-apps/bat) from dev-kit.

296+

297+```bash

298+emerge sys-apps/bat

299+```

300+

243301### On Gentoo Linux

244302

245303You can install [the `bat` package](https://packages.gentoo.org/packages/sys-apps/bat)

@@ -278,6 +336,14 @@ cd /usr/ports/textproc/bat

278336make install

279337```

280338

339+### On OpenBSD

340+

341+You can install `bat` package using [`pkg_add(1)`](https://man.openbsd.org/pkg_add.1):

342+

343+```bash

344+pkg_add bat

345+```

346+

281347### Via nix

282348

283349You can install `bat` using the [nix package manager](https://nixos.org/nix):

@@ -296,12 +362,8 @@ zypper install bat

296362

297363### Via snap package

298364

299−```

300−sudo snap install batcat

301−```

302−

303−[Get it from the Snap Store](https://snapcraft.io/batcat)

304−

365+There is currently no recommended snap package available.

366+Existing packages may be available, but are not officially supported and may contain [issues](https://github.com/sharkdp/bat/issues/1519).

305367

306368### On macOS (or Linux) via Homebrew

307369

@@ -356,7 +418,7 @@ binaries are also available: look for archives with `musl` in the file name.

356418

357419### From source

358420

359−If you want to build `bat` from source, you need Rust 1.40 or

421+If you want to build `bat` from source, you need Rust 1.51 or

360422higher. You can then use `cargo` to build everything:

361423

362424```bash

@@ -390,12 +452,11 @@ You can also use a custom theme by following the

390452

391453### 8-bit themes

392454

393−`bat` has four themes that always use [8-bit colors](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors),

455+`bat` has three themes that always use [8-bit colors](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors),

394456even when truecolor support is available:

395457

396−- `ansi-dark` looks decent on any terminal with a dark background. It uses 3-bit colors: black, red,

397− green, yellow, blue, magenta, cyan, and white.

398−- `ansi-light` is like `ansi-dark`, but for terminals with a light background.

458+- `ansi` looks decent on any terminal. It uses 3-bit colors: black, red, green,

459+ yellow, blue, magenta, cyan, and white.

399460- `base16` is designed for [base16](https://github.com/chriskempson/base16) terminal themes. It uses

400461 4-bit colors (3-bit colors plus bright variants) in accordance with the

401462 [base16 styling guidelines](https://github.com/chriskempson/base16/blob/master/styling.md).

@@ -403,10 +464,11 @@ even when truecolor support is available:

403464 It replaces certain bright colors with 8-bit colors from 16 to 21. **Do not** use this simply

404465 because you have a 256-color terminal but are not using base16-shell.

405466

406−Although these themes are more restricted, they have two advantages over truecolor themes:

467+Although these themes are more restricted, they have three advantages over truecolor themes. They:

407468

408−- They harmonize better with other terminal software using 3-bit or 4-bit colors.

409−- When you change your terminal theme, `bat` output already on the screen will update to match.

469+- Enjoy maximum compatibility. Some terminal utilities do not support more than 3-bit colors.

470+- Adapt to terminal theme changes. Even for already printed output.

471+- Visually harmonize better with other terminal software.

410472

411473### Output style

412474

@@ -482,10 +544,11 @@ You can add new (or change existing) file name patterns using the `--map-syntax`

482544command line option. The option takes an argument of the form `pattern:syntax` where

483545`pattern` is a glob pattern that is matched against the file name and

484546the absolute file path. The `syntax` part is the full name of a supported language

485−(use `bat --list-languages` for an overview)full .

547+(use `bat --list-languages` for an overview).

486548

487−Note: You probably want to use this option as an entry in `bat`s configuration file instead

488−of passing it on the command line (see below).

549+**Note:** You probably want to use this option as [an entry in `bat`'s configuration file](#configuration-file)

550+for persistence instead of passing it on the command line as a one-off. Generally

551+you'd just use `-l` if you want to manually specify a language for a file.

489552

490553Example: To use "INI" syntax highlighting for all files with a `.conf` file extension, use

491554```bash

@@ -500,7 +563,7 @@ Example: To open all files called `.ignore` (exact match) with the "Git Ignore"

500563Example: To open all `.conf` files in subfolders of `/etc/apache2` with the "Apache Conf"

501564syntax, use (this mapping is already built in):

502565```bash

503−-map-syntax='/etc/apache2/**/*.conf:Apache Conf'

566+--map-syntax='/etc/apache2/**/*.conf:Apache Conf'

504567```

505568

506569### Using a different pager

@@ -510,6 +573,8 @@ set, `less` is used by default. If you want to use a different pager, you can ei

510573`PAGER` variable or set the `BAT_PAGER` environment variable to override what is specified in

511574`PAGER`.

512575

576+**Note**: If `PAGER` is `more` or `most`, `bat` will silently use `less` instead to ensure support for colors.

577+

513578If you want to pass command-line arguments to the pager, you can also set them via the

514579`PAGER`/`BAT_PAGER` variables:

515580

@@ -559,7 +624,7 @@ alias cat="bat --theme=\$(defaults read -globalDomain AppleInterfaceStyle &> /de

559624

560625`bat` can also be customized with a configuration file. The location of the file is dependent

561626on your operating system. To get the default path for your system, call

562−```

627+```bash

563628bat --config-file

564629```

565630

@@ -589,7 +654,7 @@ Example configuration file:

589654# Use italic text on the terminal (not supported on all terminals)

590655--italic-text=always

591656

592−# Use C++ syntax for .ino files

657+# Use C++ syntax for Arduino .ino files

593658--map-syntax "*.ino:C++"

594659```

595660

@@ -641,6 +706,13 @@ bat() {

641706

642707## Troubleshooting

643708

709+### Garbled output

710+

711+If an input file contains color codes or other ANSI escape sequences or control characters, `bat` will have problems

712+performing syntax highlighting and text wrapping, and thus the output can become garbled.

713+When displaying such files it is recommended to disable both syntax highlighting and wrapping by

714+passing the `--color=never --wrap=never` options to `bat`.

715+

644716### Terminals & colors

645717

646718`bat` handles terminals *with* and *without* truecolor support. However, the colors in most syntax

@@ -692,6 +764,11 @@ bash assets/create.sh

692764cargo install --path . --locked --force

693765```

694766

767+If you want to build an application that uses `bat`s pretty-printing

768+features as a library, check out the [the API documentation](https://docs.rs/bat/).

769+Note that you have to use either `regex-onig` or `regex-fancy` as a feature

770+when you depend on `bat` as a library.

771+

695772## Contributing

696773

697774Take a look at the [`CONTRIBUTING.md`](CONTRIBUTING.md) guide.

@@ -701,6 +778,11 @@ Take a look at the [`CONTRIBUTING.md`](CONTRIBUTING.md) guide.

701778- [sharkdp](https://github.com/sharkdp)

702779- [eth-p](https://github.com/eth-p)

703780- [keith-hall](https://github.com/keith-hall)

781+- [Enselic](https://github.com/Enselic)

782+

783+## Security vulnerabilities

784+

785+Please contact [David Peter](https://david-peter.de/) via email if you want to report a vulnerability in `bat`.

704786

705787## Project goals and alternatives

706788

@@ -715,7 +797,7 @@ There are a lot of alternatives, if you are looking for similar programs. See

715797[this document](doc/alternatives.md) for a comparison.

716798

717799## License

719801

720802`bat` is made available under the terms of either the MIT License or the Apache License 2.0, at your option.

721803

assets/acknowledgements.binnew file

Binary file not shown.

assets/completions/_bat.ps1.innew file+92

@@ -0,0 +1,92 @@

2+using namespace System.Management.Automation

3+using namespace System.Management.Automation.Language

5+Register-ArgumentCompleter -Native -CommandName '{{PROJECT_EXECUTABLE}}' -ScriptBlock {

6+ param($wordToComplete, $commandAst, $cursorPosition)

8+ $commandElements = $commandAst.CommandElements

9+ $command = @(

10+ '{{PROJECT_EXECUTABLE}}'

11+ for ($i = 1; $i -lt $commandElements.Count; $i++) {

12+ $element = $commandElements[$i]

13+ if ($element -isnot [StringConstantExpressionAst] -or

14+ $element.StringConstantType -ne [StringConstantType]::BareWord -or

15+ $element.Value.StartsWith('-')) {

16+ break

17+ }

18+ $element.Value

19+ }) -join ';'

20+

21+ $completions = @(switch ($command) {

22+ '{{PROJECT_EXECUTABLE}}' {

23+ [CompletionResult]::new('-l', 'l', [CompletionResultType]::ParameterName, 'Set the language for syntax highlighting.')

24+ [CompletionResult]::new('--language', 'language', [CompletionResultType]::ParameterName, 'Set the language for syntax highlighting.')

25+ [CompletionResult]::new('-H', 'H', [CompletionResultType]::ParameterName, 'Highlight lines N through M.')

26+ [CompletionResult]::new('--highlight-line', 'highlight-line', [CompletionResultType]::ParameterName, 'Highlight lines N through M.')

27+ [CompletionResult]::new('--file-name', 'file-name', [CompletionResultType]::ParameterName, 'Specify the name to display for a file.')

28+ [CompletionResult]::new('--diff-context', 'diff-context', [CompletionResultType]::ParameterName, 'diff-context')

29+ [CompletionResult]::new('--tabs', 'tabs', [CompletionResultType]::ParameterName, 'Set the tab width to T spaces.')

30+ [CompletionResult]::new('--wrap', 'wrap', [CompletionResultType]::ParameterName, 'Specify the text-wrapping mode (*auto*, never, character).')

31+ [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''.')

32+ [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'When to use colors (*auto*, never, always).')

33+ [CompletionResult]::new('--italic-text', 'italic-text', [CompletionResultType]::ParameterName, 'Use italics in output (always, *never*)')

34+ [CompletionResult]::new('--decorations', 'decorations', [CompletionResultType]::ParameterName, 'When to show the decorations (*auto*, never, always).')

35+ [CompletionResult]::new('--paging', 'paging', [CompletionResultType]::ParameterName, 'Specify when to use the pager, or use `-P` to disable (*auto*, never, always).')

36+ [CompletionResult]::new('--pager', 'pager', [CompletionResultType]::ParameterName, 'Determine which pager to use.')

37+ [CompletionResult]::new('-m', 'm', [CompletionResultType]::ParameterName, 'Use the specified syntax for files matching the glob pattern (''*.cpp:C++'').')

38+ [CompletionResult]::new('--map-syntax', 'map-syntax', [CompletionResultType]::ParameterName, 'Use the specified syntax for files matching the glob pattern (''*.cpp:C++'').')

39+ [CompletionResult]::new('--theme', 'theme', [CompletionResultType]::ParameterName, 'Set the color theme for syntax highlighting.')

40+ [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).')

41+ [CompletionResult]::new('-r', 'r', [CompletionResultType]::ParameterName, 'Only print the lines from N to M.')

42+ [CompletionResult]::new('--line-range', 'line-range', [CompletionResultType]::ParameterName, 'Only print the lines from N to M.')

43+ [CompletionResult]::new('-A', 'A', [CompletionResultType]::ParameterName, 'Show non-printable characters (space, tab, newline, ..).')

44+ [CompletionResult]::new('--show-all', 'show-all', [CompletionResultType]::ParameterName, 'Show non-printable characters (space, tab, newline, ..).')

45+ [CompletionResult]::new('-p', 'p', [CompletionResultType]::ParameterName, 'Show plain style (alias for ''--style=plain'').')

46+ [CompletionResult]::new('--plain', 'plain', [CompletionResultType]::ParameterName, 'Show plain style (alias for ''--style=plain'').')

47+ [CompletionResult]::new('-d', 'd', [CompletionResultType]::ParameterName, 'Only show lines that have been added/removed/modified.')

48+ [CompletionResult]::new('--diff', 'diff', [CompletionResultType]::ParameterName, 'Only show lines that have been added/removed/modified.')

49+ [CompletionResult]::new('-n', 'n', [CompletionResultType]::ParameterName, 'Show line numbers (alias for ''--style=numbers'').')

50+ [CompletionResult]::new('--number', 'number', [CompletionResultType]::ParameterName, 'Show line numbers (alias for ''--style=numbers'').')

51+ [CompletionResult]::new('-f', 'f', [CompletionResultType]::ParameterName, 'f')

52+ [CompletionResult]::new('--force-colorization', 'force-colorization', [CompletionResultType]::ParameterName, 'force-colorization')

53+ [CompletionResult]::new('-P', 'P', [CompletionResultType]::ParameterName, 'Alias for ''--paging=never''')

54+ [CompletionResult]::new('--no-paging', 'no-paging', [CompletionResultType]::ParameterName, 'Alias for ''--paging=never''')

55+ [CompletionResult]::new('--list-themes', 'list-themes', [CompletionResultType]::ParameterName, 'Display all supported highlighting themes.')

56+ [CompletionResult]::new('-L', 'L', [CompletionResultType]::ParameterName, 'Display all supported languages.')

57+ [CompletionResult]::new('--list-languages', 'list-languages', [CompletionResultType]::ParameterName, 'Display all supported languages.')

58+ [CompletionResult]::new('-u', 'u', [CompletionResultType]::ParameterName, 'u')

59+ [CompletionResult]::new('--unbuffered', 'unbuffered', [CompletionResultType]::ParameterName, 'unbuffered')

60+ [CompletionResult]::new('--no-config', 'no-config', [CompletionResultType]::ParameterName, 'Do not use the configuration file')

61+ [CompletionResult]::new('--no-custom-assets', 'no-custom-assets', [CompletionResultType]::ParameterName, 'Do not load custom assets')

62+ [CompletionResult]::new('--config-file', 'config-file', [CompletionResultType]::ParameterName, 'Show path to the configuration file.')

63+ [CompletionResult]::new('--generate-config-file', 'generate-config-file', [CompletionResultType]::ParameterName, 'Generates a default configuration file.')

64+ [CompletionResult]::new('--config-dir', 'config-dir', [CompletionResultType]::ParameterName, 'Show bat''s configuration directory.')

65+ [CompletionResult]::new('--cache-dir', 'cache-dir', [CompletionResultType]::ParameterName, 'Show bat''s cache directory.')

66+ [CompletionResult]::new('--diagnostic', 'diagnostic', [CompletionResultType]::ParameterName, 'Show diagnostic information for bug reports.')

67+ [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print this help message.')

68+ [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print this help message.')

69+ [CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Show version information.')

70+ [CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Show version information.')

71+ [CompletionResult]::new('cache', 'cache', [CompletionResultType]::ParameterValue, 'Modify the syntax-definition and theme cache')

72+ break

73+ }

74+ '{{PROJECT_EXECUTABLE}};cache' {

75+ [CompletionResult]::new('--source', 'source', [CompletionResultType]::ParameterName, 'Use a different directory to load syntaxes and themes from.')

76+ [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'Use a different directory to store the cached syntax and theme set.')

77+ [CompletionResult]::new('-b', 'b', [CompletionResultType]::ParameterName, 'Initialize (or update) the syntax/theme cache.')

78+ [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'Initialize (or update) the syntax/theme cache.')

79+ [CompletionResult]::new('-c', 'c', [CompletionResultType]::ParameterName, 'Remove the cached syntax definitions and themes.')

80+ [CompletionResult]::new('--clear', 'clear', [CompletionResultType]::ParameterName, 'Remove the cached syntax definitions and themes.')

81+ [CompletionResult]::new('--blank', 'blank', [CompletionResultType]::ParameterName, 'Create completely new syntax and theme sets (instead of appending to the default sets).')

82+ [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Prints help information')

83+ [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Prints help information')

84+ [CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Prints version information')

85+ [CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Prints version information')

86+ break

87+ }

88+ })

89+

90+ $completions.Where{ $_.CompletionText -like "$wordToComplete*" } |

91+ Sort-Object -Property ListItemText

92+}

assets/completions/bat.bash.innew file+101

@@ -0,0 +1,101 @@

1+# shellcheck disable=SC2207

3+# Requires https://github.com/scop/bash-completion

5+# Macs have bash3 for which the bash-completion package doesn't include

6+# _init_completion. This is a minimal version of that function.

7+__bat_init_completion()

8+{

9+ COMPREPLY=()

10+ _get_comp_words_by_ref "$@" cur prev words cword

11+}

12+

13+_bat() {

14+ local cur prev words cword split=false

15+ if declare -F _init_completion >/dev/null 2>&1; then

16+ _init_completion -s || return 0

17+ else

18+ __bat_init_completion -n "=" || return 0

19+ _split_longopt && split=true

20+ fi

21+

22+ if [[ ${words[1]-} == cache ]]; then

23+ case $prev in

24+ --source | --target)

25+ _filedir -d

26+ return 0

27+ ;;

28+ esac

29+ COMPREPLY=($(compgen -W "

30+ --build --clear --source --target --blank --help

31+ " -- "$cur"))

32+ return 0

33+ fi

34+

35+ case $prev in

36+ -l | --language)

37+ local IFS=$'\n'

38+ COMPREPLY=($(compgen -W "$(

39+ "$1" --list-languages | while IFS=: read -r lang _; do

40+ printf "%s\n" "$lang"

41+ done

42+ )" -- "$cur"))

43+ compopt -o filenames # for escaping

44+ return 0

45+ ;;

47+ -m | --map-syntax | --style | --line-range | -h | --help | -V | \

48+ --version | --diagnostic | --config-file | --config-dir | \

49+ --cache-dir | --generate-config-file)

50+ # argument required but no completion available, or option

51+ # causes an exit

52+ return 0

53+ ;;

54+ --file-name)

55+ _filedir

56+ return 0

57+ ;;

58+ --wrap)

59+ COMPREPLY=($(compgen -W "auto never character" -- "$cur"))

60+ return 0

61+ ;;

62+ --color | --decorations | --paging)

63+ COMPREPLY=($(compgen -W "auto never always" -- "$cur"))

64+ return 0

65+ ;;

66+ --italic-text)

67+ COMPREPLY=($(compgen -W "always never" -- "$cur"))

68+ return 0

69+ ;;

70+ --pager)

71+ COMPREPLY=($(compgen -c -- "$cur"))

72+ return 0

73+ ;;

74+ --theme)

75+ local IFS=$'\n'

76+ COMPREPLY=($(compgen -W "$("$1" --list-themes)" -- "$cur"))

77+ compopt -o filenames # for escaping

78+ return 0

79+ ;;

80+ esac

81+

82+ $split && return 0

83+

84+ if [[ $cur == -* ]]; then

85+ COMPREPLY=($(compgen -W "

86+ --show-all --plain --language --highlight-line

87+ --file-name --diff --diff-context --tabs --wrap

88+ --terminal-width --number --color --italic-text

89+ --decorations --paging --pager --map-syntax --theme

90+ --list-themes --style --line-range --list-languages

91+ --help --version --force-colorization --unbuffered

92+ --diagnostic --config-file --config-dir --cache-dir

93+ --generate-config-file

94+ " -- "$cur"))

95+ return 0

96+ fi

97+

98+ _filedir

99+ ((cword == 1)) && COMPREPLY+=($(compgen -W cache -- "$cur"))

100+

101+} && complete -F _bat {{PROJECT_EXECUTABLE}}

assets/completions/bat.fish.in+2−2

@@ -34,7 +34,7 @@ complete -c {{PROJECT_EXECUTABLE}} -s H -l highlight-line -x -d "<N> Highlight t

3434

3535complete -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"

3636

37−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)"

37+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)"

3838

3939complete -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"

4040

@@ -56,7 +56,7 @@ complete -c {{PROJECT_EXECUTABLE}} -s P -d "Disable paging. Alias for '--paging=

5656

5757complete -c {{PROJECT_EXECUTABLE}} -s A -l show-all -d "Show non-printable characters like space/tab/newline" -n "not __fish_seen_subcommand_from cache"

5858

59−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"

59+complete -c {{PROJECT_EXECUTABLE}} -l style -xka "default auto full plain changes header header-filename header-filesize grid rule numbers snip" -d "Comma-separated list of style elements or presets to display with file contents" -n "not __fish_seen_subcommand_from cache"

6060

6161complete -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"

6262

assets/completions/bat.zsh.in+7−1

@@ -44,6 +44,12 @@ _{{PROJECT_EXECUTABLE}}_main() {

4444 '(--style)'--style='[Comma-separated list of style elements to display]:<components>:->style'

4545 '(-r --line-range)'{-r+,--line-range=}'[Only print the lines from N to M]:<N\:M>...'

4646 '(: --list-themes --list-languages -L)'{-L,--list-languages}'[Display all supported languages]'

47+ '(: --no-config)'--no-config'[Do not use the configuration file]'

48+ '(: --no-custom-assets)'--no-custom-assets'[Do not load custom assets]'

49+ '(: --config-dir)'--config-dir'[Show bat'"'"'s configuration directory]'

50+ '(: --config-file)'--config-file'[Show path to the configuration file]'

51+ '(: --generate-config-file)'--generate-config-file'[Generates a default configuration file]'

52+ '(: --cache-dir)'--cache-dir'[Show bat'"'"'s cache directory]'

4753 '(: -)'{-h,--help}'[Print this help message]'

4854 '(: -)'{-V,--version}'[Show version information]'

4955 '*: :_files'

@@ -69,7 +75,7 @@ _{{PROJECT_EXECUTABLE}}_main() {

6975 ;;

7076

7177 style)

72− _values -s , 'style' auto full plain changes header grid numbers snip

78+ _values -s , 'style' default auto full plain changes header header-filename header-filesize grid rule numbers snip

7379 ;;

7480 esac

7581}

assets/create.sh+14−8

@@ -5,7 +5,7 @@ ASSET_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"

55REPO_DIR="$ASSET_DIR/.."

77# Ensure submodules are initialized.

8−function update_submodules() {

8+update_submodules() {

99 local submodule

1010 local submodule_prompt=unspecified

1111 local submodule_path

@@ -46,6 +46,7 @@ bat cache --clear

4646# - Remove the JavaDoc patch once https://github.com/trishume/syntect/issues/222 has been fixed

4747# - Remove the C# patch once https://github.com/sublimehq/Packages/pull/2331 has been merged

4848

49+# Apply patches

4950(

5051 cd "$ASSET_DIR"

5152 for patch in patches/*.patch; do

@@ -53,11 +54,16 @@ bat cache --clear

5354 done

5455)

5556

56−bat cache --build --blank --source="$ASSET_DIR" --target="$ASSET_DIR"

57+reverse_patches() {

58+ (

59+ cd "$ASSET_DIR"

60+ for patch in patches/*.patch; do

61+ patch --strip=0 --reverse <"$patch"

62+ done

63+ )

64+}

5765

58−(

59− cd "$ASSET_DIR"

60− for patch in patches/*.patch; do

61− patch --strip=0 --reverse < "$patch"

62− done

63−)

66+# Make sure to always reverse patches, even if the `bat cache` command fails or aborts

67+trap reverse_patches EXIT

68+

69+bat cache --build --blank --acknowledgements --source="$ASSET_DIR" --target="$ASSET_DIR"

assets/manual/bat.1.in+27−3

@@ -40,7 +40,7 @@ language names and file extensions.

4040.HP

4141\fB\-H\fR, \fB\-\-highlight\-line\fR <N:M>...

4242.IP

43−Highlight the specified line ranges with a different background color For example:

43+Highlight the specified line ranges with a different background color. For example:

4444.RS

4545.IP "\-\-highlight\-line 40"

4646highlights line 40

@@ -50,8 +50,22 @@ highlights lines 30 to 40

5050highlights lines 1 to 40

5151.IP "\-\-highlight\-line 40:"

5252highlights lines 40 to the end of the file

53+.IP "\-\-highlight\-line 30:+10"

54+highlights lines 30 to 40

5355.RE

5456.HP

57+\fB\-\-file\-name\fR <name>...

58+.IP

59+Specify the name to display for a file. Useful when piping data to {{PROJECT_EXECUTABLE}} from STDIN when {{PROJECT_EXECUTABLE}} does not otherwise know the filename. Note that the provided file name is also used for syntax detection.

60+.HP

61+\fB\-d\fR, \fB\-\-diff\fR

62+.IP

63+Only show lines that have been added/removed/modified with respect to the Git index. Use '\-\-diff\-context=N' to control how much context you want to see.

64+.HP

65+\fB\-\-diff\-context\fR <N>...

66+.IP

67+Include N lines of context around added/removed/modified lines when using '\-\-diff'.

68+.HP

5569\fB\-\-tabs\fR <T>

5670.IP

5771Set the tab width to T spaces. Use a width of 0 to pass tabs through directly

@@ -104,6 +118,8 @@ which pager is used, see the '\-\-pager' option. Possible values: *auto*, never,

104118Determine which pager is used. This option will override the PAGER and BAT_PAGER

105119environment variables. The default pager is 'less'. To control when the pager is used, see

106120the '\-\-paging' option. Example: '\-\-pager "less \fB\-RF\fR"'.

121+

122+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.

107123.HP

108124\fB\-m\fR, \fB\-\-map\-syntax\fR <glob-pattern:syntax-name>...

109125.IP

@@ -111,6 +127,7 @@ Map a glob pattern to an existing syntax name. The glob pattern is matched on th

111127path and the filename. For example, to highlight *.build files with the Python syntax,

112128use -m '*.build:Python'. To highlight files named '.myignore' with the Git Ignore

113129syntax, use -m '.myignore:Git Ignore'.

130+Note that the right-hand side is the *name* of the syntax, not a file extension.

114131.HP

115132\fB\-\-theme\fR <theme>

116133.IP

@@ -129,7 +146,8 @@ Configure which elements (line numbers, file headers, grid borders, Git modifica

129146of components to display (e.g. 'numbers,changes,grid') or a pre\-defined style ('full').

130147To set a default style, add the '\-\-style=".."' option to the configuration file or

131148export the BAT_STYLE environment variable (e.g.: export BAT_STYLE=".."). Possible

132−values: *auto*, full, plain, changes, header, grid, rule, numbers, snip.

149+values: *default*, full, auto, plain, changes, header, header-filename, header-filesize, grid,

150+rule, numbers, snip.

133151.HP

134152\fB\-r\fR, \fB\-\-line\-range\fR <N:M>...

135153.IP

@@ -141,6 +159,8 @@ prints lines 30 to 40

141159prints lines 1 to 40

142160.IP "\-\-line\-range 40:"

143161prints lines 40 to the end of the file

162+.IP "\-\-line\-range 30:+10"

163+prints lines 30 to 40

144164.RE

145165.HP

146166\fB\-L\fR, \fB\-\-list\-languages\fR

@@ -176,6 +196,10 @@ is dependent on your operating system. To get the default path for your system,

176196

177197Alternatively, you can use the BAT_CONFIG_PATH environment variable to point {{PROJECT_EXECUTABLE}} to a non-default

178198location of the configuration file.

199+

200+To generate a default configuration file, call:

201+

202+\fB{{PROJECT_EXECUTABLE}} --generate-config-file\fR

179203.SH "ADDING CUSTOM LANGUAGES"

180204{{PROJECT_EXECUTABLE}} supports Sublime Text \fB.sublime-syntax\fR language files, and can be

181205customized to add additional languages to your local installation. To do this, add the \fB.sublime-syntax\fR language

@@ -201,7 +225,7 @@ git clone https://github.com/tellnobody1/sublime-purescript-syntax

201225

202226Once the cache is built, the new language will be visible in `\fB{{PROJECT_EXECUTABLE}} --list-languages\fR`.

203227.br

204−If you ever want to remove the custom languages, you can clear the cache with `\fB{{PROJECT_EXECUTABLE}} cache --clear\fR`.

228+If you ever want to remove the custom languages, you can clear the cache with `\fB{{PROJECT_EXECUTABLE}} cache --clear\fR`.

205229

206230.SH "ADDING CUSTOM THEMES"

207231Similarly to custom languages, {{PROJECT_EXECUTABLE}} supports Sublime Text \fB.tmTheme\fR themes.

assets/patches/Groff.sublime-syntax.patchnew file+16

@@ -0,0 +1,16 @@

1+diff --git syntaxes/02_Extra/Groff/Man Page/Man Page.sublime-syntax syntaxes/02_Extra/Groff/Man Page/Man Page.sublime-syntax

2+index 57834af..6648664 100644

3+--- syntaxes/02_Extra/Groff/Man Page/Man Page.sublime-syntax

4++++ syntaxes/02_Extra/Groff/Man Page/Man Page.sublime-syntax

5+@@ -4,9 +4,9 @@

6+ # - man-pages(7)

7+ # - groff(7)

8+ ---

9+-name: Man Page (groff/troff)

10++name: Groff/troff

11+ scope: text.groff

12+-file_extensions: [man, groff, troff, '1', '2', '3', '4', '5', '6', '7']

13++file_extensions: [groff, troff, '1', '2', '3', '4', '5', '6', '7', '8', '9']

14+

15+ contexts:

16+ main:

assets/patches/Markdown.sublime-syntax.patch+10−1

@@ -1,5 +1,5 @@

11diff --git syntaxes/01_Packages/Markdown/Markdown.sublime-syntax syntaxes/01_Packages/Markdown/Markdown.sublime-syntax

2−index 19dc685d..6afd87ae 100644

2+index 19dc685d..44440c7f 100644

33--- syntaxes/01_Packages/Markdown/Markdown.sublime-syntax

44+++ syntaxes/01_Packages/Markdown/Markdown.sublime-syntax

55@@ -24,7 +24,6 @@ variables:

@@ -166,3 +166,12 @@ index 19dc685d..6afd87ae 100644

166166 - match: ^\s*$\n?

167167 scope: invalid.illegal.non-terminated.bold-italic.markdown

168168 pop: true

169+@@ -1152,7 +1110,7 @@ contexts:

170+ - match: |-

171+ (?x)

172+ {{fenced_code_block_start}}

173+- ((?i:rust))

174++ ((?i:rust|rs))

175+ {{fenced_code_block_trailing_infostring_characters}}

176+ captures:

177+ 0: meta.code-fence.definition.begin.rust.markdown-gfm

assets/patches/MediaWiki.sublime-syntax.patchnew file+13

@@ -0,0 +1,13 @@

1+diff --git syntaxes/02_Extra/MediaWiki/MediawikiNG.sublime-syntax syntaxes/02_Extra/MediaWiki/MediawikiNG.sublime-syntax

2+index f542c9e..8eaf020 100644

3+--- syntaxes/02_Extra/MediaWiki/MediawikiNG.sublime-syntax

4++++ syntaxes/02_Extra/MediaWiki/MediawikiNG.sublime-syntax

5+@@ -1,7 +1,7 @@

6+ %YAML 1.2

7+ ---

8+ # http://www.sublimetext.com/docs/3/syntax.html

9+-name: Mediawiki NG

10++name: MediaWiki

11+ file_extensions: [mediawiki, wikipedia, wiki]

12+ scope: text.html.mediawiki

13+

assets/patches/Monokai-Extended.tmTheme.patchnew file+36

@@ -0,0 +1,36 @@

1+diff --git themes/sublime-monokai-extended/Monokai\ Extended.tmTheme themes/sublime-monokai-extended/Monokai\ Extended.tmTheme

2+index 9c2aa3e..180cbbf 100644

3+--- themes/sublime-monokai-extended/Monokai Extended.tmTheme

4++++ themes/sublime-monokai-extended/Monokai Extended.tmTheme

5+@@ -810,11 +810,11 @@

6+ <key>name</key>

7+ <string>JSON String</string>

8+ <key>scope</key>

9+- <string>meta.structure.dictionary.json string.quoted.double.json</string>

10++ <string>meta.mapping.key.json string.quoted.double.json, punctuation.separator.sequence.csv</string>

11+ <key>settings</key>

12+ <dict>

13+ <key>foreground</key>

14+- <string>#cfcfc2</string>

15++ <string>#fd971f</string>

16+ </dict>

17+ </dict>

18+ <dict>

19+@@ -1027,7 +1027,7 @@

20+ <key>name</key>

21+ <string>Invalid</string>

22+ <key>scope</key>

23+- <string>invalid</string>

24++ <string>invalid, markup.error</string>

25+ <key>settings</key>

26+ <dict>

27+ <key>background</key>

28+@@ -1042,7 +1042,7 @@

29+ <key>name</key>

30+ <string>Invalid deprecated</string>

31+ <key>scope</key>

32+- <string>invalid.deprecated</string>

33++ <string>invalid.deprecated, markup.warning</string>

34+ <key>settings</key>

35+ <dict>

36+ <key>background</key>

assets/patches/Python.sublime-syntax.patchnew file+15

@@ -0,0 +1,15 @@

1+diff --git syntaxes/01_Packages/Python/Python.sublime-syntax syntaxes/01_Packages/Python/Python.sublime-syntax

2+index 2acd86d8..86257f7b 100644

3+--- syntaxes/01_Packages/Python/Python.sublime-syntax

4++++ syntaxes/01_Packages/Python/Python.sublime-syntax

5+@@ -988,10 +988,6 @@ contexts:

6+ - match: \}

7+ scope: punctuation.section.mapping-or-set.end.python

8+ set: after-expression

9+- - match: (?={{simple_expression}}:|\s*\*\*)

10+- set: inside-dictionary

11+- - match: (?={{simple_expression}}[,}]|\s*\*)

12+- set: inside-set

13+ - match: ','

14+ scope: punctuation.separator.set.python

15+ set: inside-set

assets/patches/ShellScript.sublime-syntax.patch+7−2

@@ -1,8 +1,8 @@

11diff --git syntaxes/01_Packages/ShellScript/Bash.sublime-syntax syntaxes/01_Packages/ShellScript/Bash.sublime-syntax

2−index e973e319..a703cef8 100644

2+index e973e319..07c170a7 100644

33--- syntaxes/01_Packages/ShellScript/Bash.sublime-syntax

44+++ syntaxes/01_Packages/ShellScript/Bash.sublime-syntax

5−@@ -30,8 +30,8 @@ file_extensions:

5+@@ -30,12 +30,12 @@ file_extensions:

66 - .zshenv

77 - .zshrc

88 - PKGBUILD # https://jlk.fjfi.cvut.cz/arch/manpages/man/PKGBUILD.5

@@ -13,3 +13,8 @@ index e973e319..a703cef8 100644

1313

1414 first_line_match: |

1515 (?x)

16+- ^\#! .* \b(bash|zsh|sh|tcsh|ash)\b

17++ ^\#! .* \b(bash|zsh|sh|tcsh|ash|dash)\b

18+ | ^\# \s* -\*- [^*]* mode: \s* shell-script [^*]* -\*-

19+

20+ #-------------------------------------------------------------------------------

assets/patches/XML.sublime-syntax.patchnew file+12

@@ -0,0 +1,12 @@

1+diff --git syntaxes/01_Packages/XML/XML.sublime-syntax syntaxes/01_Packages/XML/XML.sublime-syntax

2+index ad7d9c87..af4a00f0 100644

3+--- syntaxes/01_Packages/XML/XML.sublime-syntax

4++++ syntaxes/01_Packages/XML/XML.sublime-syntax

5+@@ -12,6 +12,7 @@ file_extensions:

6+ - rss

7+ - opml

8+ - svg

9++ - xaml

10+ first_line_match: |-

11+ (?x:

12+ ^(?:

assets/syntaxes.bin

Binary file not shown.

assets/syntaxes/02_Extra/CMake+1−1

Submodule changed.

assets/syntaxes/02_Extra/CSVdeleted−1

Submodule changed.

assets/syntaxes/02_Extra/CSV.sublime-syntax+71−39

@@ -1,46 +1,78 @@

11%YAML 1.2

22---

3−# http://www.sublimetext.com/docs/3/syntax.html

4−name: Advanced CSV

3+# See http://www.sublimetext.com/docs/3/syntax.html

4+name: Comma Separated Values

55file_extensions:

66 - csv

77 - tsv

8−scope: text.advanced_csv

8+scope: text.csv

9+variables:

10+ field_separator: (?:[,;\t])

11+ record_separator: (?:$\n?)

912contexts:

10− main:

11− - match: (\")

12− captures:

13− 1: string.quoted.double.advanced_csv

14− push:

15− - meta_scope: meta.quoted.advanced_csv

16− - match: (\")

17− captures:

18− 1: string.quoted.double.advanced_csv

19− pop: true

20− - include: main

21− - match: '(\[([+-]?\d*)(\:)?([+-]?\d*)(\,)?([+-]?\d*)(\:)?([+-]?\d*)\])?\s*([<>v^])?\s*(=)'

22− captures:

23− 1: keyword.operator.advanced_csv

24− 2: constant.numeric.formula.advanced_csv

25− 4: constant.numeric.formula.advanced_csv

26− 6: constant.numeric.formula.advanced_csv

27− 8: constant.numeric.formula.advanced_csv

28− 9: keyword.operator.advanced_csv

29− 10: keyword.operator.advanced_csv

13+ prototype:

14+ - match: (?={{record_separator}})

15+ pop: true

16+ fields:

17+ - match: ''

3018 push:

31− - meta_scope: meta.range.advanced_csv

32− - match: (?=(\")|$)

33− pop: true

34− - include: scope:source.python

35− - match: '(?<=^|,|\s|\")([0-9.eE+-]+)(?=$|,|\s|\")'

36− scope: meta.number.advanced_csv

37− captures:

38− 1: constant.numeric.advanced_csv

39− - match: '(?<=^|,|\s|\")([^, \t\"]+)(?=$|,|\s|\")'

40− scope: meta.nonnumber.advanced_csv

41− captures:

42− 1: storage.type.advanced_csv

43− - match: (\,)

44− scope: meta.delimiter.advanced_csv

45− captures:

46− 1: keyword.operator.advanced_csv

19+ - field_or_record_separator

20+ - field4

21+ - field_or_record_separator

22+ - field3

23+ - field_or_record_separator

24+ - field2

25+ - field_or_record_separator

26+ - field1

27+ main:

28+ - meta_include_prototype: false

29+ - match: '^'

30+ set: fields

31+

32+ field_or_record_separator:

33+ - meta_include_prototype: false

34+ - match: '{{record_separator}}'

35+ scope: punctuation.terminator.record.csv

36+ pop: true

37+ - match: '{{field_separator}}'

38+ scope: punctuation.separator.sequence.csv

39+ pop: true

40+

41+ field_contents:

42+ - match: '"'

43+ scope: punctuation.definition.string.begin.csv

44+ push: double_quoted_string

45+

46+ - match: (?={{field_separator}}|{{record_separator}})

47+ pop: true

48+

49+ double_quoted_string:

50+ - meta_include_prototype: false

51+ - meta_scope: string.quoted.double.csv

52+ - match: '""'

53+ scope: constant.character.escape.csv

54+ - match: '"'

55+ scope: punctuation.definition.string.end.csv

56+ pop: true

57+

58+ field1:

59+ - match: ''

60+ set:

61+ - meta_content_scope: meta.field-1.csv support.type

62+ - include: field_contents

63+ field2:

64+ - match: ''

65+ set:

66+ - meta_content_scope: meta.field-2.csv support.function

67+ - include: field_contents

68+ field3:

69+ - match: ''

70+ set:

71+ - meta_content_scope: meta.field-3.csv constant.numeric

72+ - include: field_contents

73+ field4:

74+ - match: ''

75+ set:

76+ - meta_content_scope: meta.field-4.csv keyword.operator

77+ - include: field_contents

78+

assets/syntaxes/02_Extra/Crystal+1−1

Submodule changed.

assets/syntaxes/02_Extra/Dart+1−1

Submodule changed.

assets/syntaxes/02_Extra/Dart.sublime-syntax+85−243

@@ -1,6 +1,6 @@

11%YAML 1.2

22---

3−# http://www.sublimetext.com/docs/3/syntax.html

3+# http://www.sublimetext.com/docs/syntax.html

44name: Dart

55file_extensions:

66 - dart

@@ -9,7 +9,7 @@ contexts:

99 main:

1010 - match: ^(#!.*)$

1111 scope: meta.preprocessor.script.dart

12− - match: ^\s*\b(library|import|export|part of|part)\b

12+ - match: ^\w*\b(library|import|part of|part|export)\b

1313 captures:

1414 0: keyword.other.import.dart

1515 push:

@@ -19,242 +19,114 @@ contexts:

1919 0: punctuation.terminator.dart

2020 pop: true

2121 - include: strings

22− - match: \b(as|show|hide|deferred)\b

22+ - include: comments

23+ - match: \b(as|show|hide)\b

2324 scope: keyword.other.import.dart

2425 - include: comments

25− - include: constants-and-special-vars

26+ - include: punctuation

2627 - include: annotations

27− - include: decl-typedef

28− - include: decl-class

29− - include: decl-enum

30− - include: decl-function

3128 - include: keywords

29+ - include: constants-and-special-vars

3230 - include: strings

3331 annotations:

34− - match: '^(?:\s*)((@)([a-zA-Z0-9_]+))'

35− captures:

36− 1: annotation.dart

37− 2: entity.name.function.annotation.dart

38− 3: support.type.dart

32+ - match: '@[a-zA-Z]+'

33+ scope: storage.type.annotation.dart

3934 comments:

4035 - match: /\*\*/

4136 scope: comment.block.empty.dart

4237 captures:

4338 0: punctuation.definition.comment.dart

39+ - include: comments-doc-oldschool

40+ - include: comments-doc

4441 - include: comments-inline

45− comments-inline:

42+ comments-block:

4643 - match: /\*

4744 push:

4845 - meta_scope: comment.block.dart

4946 - match: \*/

5047 pop: true

51− - include: scope:text.dart-doccomments

52− - match: (///)

53− captures:

54− 1: marker.dart

48+ - include: comments-block

49+ comments-doc:

50+ - match: ///

5551 push:

56− - meta_scope: comment.line.triple-slash.dart

57− - match: $

52+ - meta_scope: comment.block.documentation.dart

53+ - match: .*

5854 pop: true

59− - include: scope:text.dart-doccomments

60− - match: (//)

61− captures:

62− 1: marker.dart

55+ - include: dartdoc

56+ comments-doc-oldschool:

57+ - match: /\*\*

6358 push:

64− - meta_scope: comment.line.double-slash.dart

65− - match: $

59+ - meta_scope: comment.block.documentation.dart

60+ - match: \*/

6661 pop: true

67− - include: scope:text.dart-doccomments

62+ - include: comments-doc-oldschool

63+ - include: comments-block

64+ - include: dartdoc

65+ comments-inline:

66+ - include: comments-block

67+ - match: ((//).*)$

68+ captures:

69+ 1: comment.line.double-slash.dart

6870 constants-and-special-vars:

69− - match: \b(true|false|null)\b

71+ - match: (?<!\$)\b(true|false|null)\b(?!\$)

7072 scope: constant.language.dart

71− - match: \b(this|super)\b

73+ - match: (?<!\$)\b(this|super)\b(?!\$)

7274 scope: variable.language.dart

73− - match: '\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)\b'

75+ - match: '(?<!\$)\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)\b(?!\$)'

7476 scope: constant.numeric.dart

75− decl-class:

76− - match: \bclass\b

78+ scope: support.class.dart

79+ - match: '([_$]*[a-z][a-zA-Z0-9_$]*)(<|\(|\s+=>)'

7780 captures:

78− 0: keyword.control.new.dart

79− push:

80− - meta_scope: meta.declaration.class.dart

81− - match: "(?={)"

82− pop: true

83− - include: keywords

84− - match: "[A-Za-z_][A-Za-z0-9_]*"

85− scope: class.name.dart

86− decl-enum:

87− - match: \benum\b

88− captures:

89− 0: keyword.declaration.dart

90− push:

91− - meta_scope: meta.declaration.enum.dart

92− - match: "(?={)"

93− pop: true

94− - include: keywords

95− - match: "[A-Za-z_][A-Za-z0-9_]*"

96− scope: enum.name.dart

97− decl-function:

99− comment: A getter with a primitive return type.

100− scope: meta.declaration.function.dart

81+ 1: entity.name.function.dart

82+ dartdoc:

83+ - match: '(\[.*?\])'

10184 captures:

102− 1: storage.type.primitive.dart

103− 2: keyword.declaration.dart

104− 3: function.name.dart

105− - match: ^\s*(?:\b(\w+)\b\s+)?(get)\s+(\w+)\s+(?==>)

106− comment: A getter with a user-defined return type or no return type.

107− scope: meta.declaration.function.dart

108− captures:

109− 1: type.user-defined.dart

110− 2: keyword.declaration.dart

111− 3: function.name.dart

112− - match: ^\s*(set)\s+(\w+)(?=\()

113− comment: A setter.

114− captures:

115− 1: keyword.declaration.dart

116− 2: function.name.dart

117− push:

118− - meta_scope: meta.declaration.function.dart

119− - match: \)

120− pop: true

121− - include: comments-inline

122− - include: decl-function-parameter

123− - include: strings

124− - include: keywords

126− comment: A function with a primitive return type.

127− captures:

128− 1: storage.type.primitive.dart

129− 2: function.name.dart

130− push:

131− - meta_scope: meta.declaration.function.dart

132− - match: \)

133− pop: true

134− - include: comments-inline

135− - include: decl-function-parameter

136− - include: strings

137− - include: keywords

138− - match: ^\s*(?:\b(return)\b)\s+(\w+)(?=\()

139− comment: A function invocation after 'return'

140− captures:

141− 1: keyword.control.dart

142− 2: function.name.dart

143− push:

144− - meta_scope: meta.invocation.function.dart

145− - match: \)

146− pop: true

147− - include: comments-inline

148− - include: decl-function-parameter

149− - include: strings

150− - include: keywords

151− - match: ^\s*\b(new)\b\s+(\w+)(?=\()

152− comment: A class instantiation after 'new'

153− captures:

154− 1: keyword.declaration.dart

155− 2: function.name.dart

156− push:

157− - meta_scope: meta.invocation.function.dart

158− - match: \)

159− pop: true

160− - include: comments-inline

161− - include: decl-function-parameter

162− - include: strings

163− - include: keywords

164− decl-function-parameter:

165− - include: constants-and-special-vars

167− comment: A function with a primitive return type.

168− captures:

169− 1: storage.type.primitive.dart

170− 2: function.name.dart

171− push:

172− - meta_scope: meta.parameter.function.dart

173− - match: \)

174− pop: true

175− - include: decl-function-parameter

176− - include: strings

177− - include: keywords

178− - match: \b(new)\b\s+(\w+)(?=\()

179− comment: A class instantiation after 'new'

85+ 0: variable.name.source.dart

86+ - match: '^ {4,}(?![ \*]).*'

18087 captures:

181− 1: keyword.declaration.dart

182− 2: function.name.dart

88+ 0: variable.name.source.dart

89+ - match: '```.*?$'

18390 push:

184− - meta_scope: meta.invocation.function.dart

185− - match: \)

91+ - meta_content_scope: variable.other.source.dart

92+ - match: '```'

18693 pop: true

187− - include: decl-function-parameter

188− - include: strings

189− - include: keywords

190− - match: (?:\b(\w+)\b)\s+(\w+)(?=\()

191− comment: A function with a user-defined return type.

94+ - match: (`.*?`)

19295 captures:

193− 1: type.user-defined.dart

194− 2: function.name.dart

195− push:

196− - meta_scope: meta.parameter.function.dart

197− - match: \)

198− pop: true

199− - include: decl-function-parameter

200− - include: strings

201− - include: keywords

202− - match: (\w+)(?=\()

203− comment: A function with no return type.

96+ 0: variable.other.source.dart

97+ - match: (`.*?`)

20498 captures:

205− 1: function.name.dart

206− push:

207− - meta_scope: meta.parameter.function.dart

208− - match: \)

209− pop: true

210− - include: decl-function-parameter

211− - include: strings

212− - include: keywords

213− decl-typedef:

214− - match: typedef

99+ 0: variable.other.source.dart

100+ - match: (\* (( ).*))$

215101 captures:

216− 0: keyword.control.new.dart

217− push:

218− - meta_scope: meta.declaration.typedef.dart

219− - match: ;

220− captures:

221− 0: punctuation.terminator.dart

222− pop: true

224− captures:

225− 1: storage.type.primitive.dart

226− 2: typedef.return.dart

227− 3: typedef.name.dart

228− - match: \(

229− push:

230− - meta_scope: typedef.params.dart

231− - match: \)

232− pop: true

233− - include: keywords

102+ 2: variable.other.source.dart

103+ - match: (\* .*)$

234104 keywords:

235− - match: \bassert\b

236− scope: keyword.control.assert.dart

237− - match: \bas\b

105+ - match: (?<!\$)\bas\b(?!\$)

238106 scope: keyword.cast.dart

240108 scope: keyword.control.catch-exception.dart

241− - match: \s+\?\s+|\s+:\s+

242− scope: keyword.control.ternary.dart

244110 scope: keyword.control.dart

245− - match: \b(async\*|async|await\*|await|yield)\b

246− scope: keyword.control.async.dart

247− - match: \b(new)\b

111+ - match: (?<!\$)\b(sync(\*)?|async(\*)?|await|yield(\*)?)\b(?!\$)

112+ scope: keyword.control.dart

113+ - match: (?<!\$)\bassert\b(?!\$)

114+ scope: keyword.control.dart

115+ - match: (?<!\$)\b(new)\b(?!\$)

248116 scope: keyword.control.new.dart

250118 scope: keyword.declaration.dart

251− - match: \b(is\!?)\b

119+ - match: (?<!\$)\b(is\!?)\b(?!\$)

252120 scope: keyword.operator.dart

121+ - match: '\?|:'

122+ scope: keyword.operator.ternary.dart

253123 - match: (<<|>>>?|~|\^|\||&)

254124 scope: keyword.operator.bitwise.dart

255125 - match: ((&|\^|\||<<|>>>?)=)

256126 scope: keyword.operator.assignment.bitwise.dart

257− - match: (===?|!==?|<=?|>=?)

127+ - match: (=>)

128+ scope: keyword.operator.closure.dart

129+ - match: (==|!=|<=?|>=?)

258130 scope: keyword.operator.comparison.dart

259131 - match: '(([+*/%-]|\~)=)'

260132 scope: keyword.operator.assignment.arithmetic.dart

@@ -266,56 +138,22 @@ contexts:

266138 scope: keyword.operator.arithmetic.dart

267139 - match: (!|&&|\|\|)

268140 scope: keyword.operator.logical.dart

269− - match: ;

270− scope: punctuation.terminator.dart

271− - match: \b(static|final|const)\b

141+ - match: (?<!\$)\b(static|final|const)\b(?!\$)

272142 scope: storage.modifier.dart

143+ - match: (?<!\$)\b(?:void|var)\b(?!\$)

274144 scope: storage.type.primitive.dart

275− regexp:

276− - match: '\\[^''"]'

277− scope: constant.character.escaped.regex.dart

278− - match: \(

279− push:

280− - meta_content_scope: meta.capture.regex.dart

281− - match: \)

282− pop: true

283− - match: \?(:|=|!)

284− scope: ignore.capture.regex.dart

285− - match: \*|\+|\?|\.|\|

286− scope: keyword.other.regex.dart

287− - match: \^|\$

288− scope: keyword.other.regex.dart

145+ punctuation:

146+ - match: ','

147+ scope: punctuation.comma.dart

148+ - match: ;

149+ scope: punctuation.terminator.dart

289150 - match: \.

290− scope: constant.other.regex.dart

291− - match: '\[(\^)?'

292− captures:

293− 1: keyword.other.negation.regex.dart

294− push:

295− - meta_scope: constant.character.range.regex.dart

296− - match: '\]'

297− pop: true

298− - match: '\\[^"'']'

299− scope: constant.character.escaped.regex.dart

300− - match: '\{(?:\d+)?,(?:\d+)?\}'

301− scope: keyword.other.regex.dart

151+ scope: punctuation.dot.dart

302152 string-interp:

303− - match: '(\$)(\{)'

153+ - match: '\$((\w+)|\{([^{}]+)\})'

304154 captures:

305− 1: keyword.other.dart

306− 2: keyword.other.dart

307− push:

308− - meta_scope: interpolation.dart

309− - meta_content_scope: source.dart

310− - match: '(\})'

311− captures:

312− 1: keyword.other.dart

313− pop: true

314− - include: main

315− - match: (\$)(\w+)

316− captures:

317− 1: keyword.other.dart

318155 2: variable.parameter.dart

156+ 3: variable.parameter.dart

319157 - match: \\.

320158 scope: constant.character.escape.dart

321159 strings:

@@ -328,7 +166,7 @@ contexts:

328166 - match: (?<!r)'''

329167 push:

330168 - meta_scope: string.interpolated.triple.single.dart

331− - match: "'''(?!')"

169+ - match: '''''''(?!'')'

332170 pop: true

333171 - include: string-interp

334172 - match: r"""

@@ -339,9 +177,9 @@ contexts:

339177 - match: r'''

340178 push:

341179 - meta_scope: string.quoted.triple.single.dart

342− - match: "'''(?!')"

180+ - match: '''''''(?!'')'

343181 pop: true

344− - match: (?<!\\|r)"

182+ - match: (?<!\|r)"

345183 push:

346184 - meta_scope: string.interpolated.double.dart

347185 - match: '"'

@@ -354,16 +192,20 @@ contexts:

354192 - meta_scope: string.quoted.double.dart

355193 - match: '"'

356194 pop: true

357− - include: regexp

195+ - match: \n

196+ scope: invalid.string.newline

358197 - match: (?<!\|r)'

359198 push:

360199 - meta_scope: string.interpolated.single.dart

361200 - match: "'"

362201 pop: true

202+ - match: \n

203+ scope: invalid.string.newline

363204 - include: string-interp

364205 - match: r'

365206 push:

366207 - meta_scope: string.quoted.single.dart

367208 - match: "'"

368209 pop: true

369− - include: regexp

210+ - match: \n

211+ scope: invalid.string.newline

assets/syntaxes/02_Extra/DotENV+1−1

Submodule changed.

assets/syntaxes/02_Extra/DotENV.sublime-syntax+4−2

@@ -4,7 +4,6 @@

44name: DotENV

55file_extensions:

66 - .env

7− - .envrc

87 - .env.dist

98 - .env.local

109 - .env.sample

@@ -19,8 +18,11 @@ file_extensions:

1918 - .env.production

2019 - .env.production.local

2120 - .env.dusk.local

22− - .flaskenv

2321 - .env.staging

22+ - .env.default

23+ - .env.defaults

24+ - .envrc

25+ - .flaskenv

2426scope: source.env

2527contexts:

2628 main:

assets/syntaxes/02_Extra/FSharp+1−1

Submodule changed.

assets/syntaxes/02_Extra/Fish+1−1

Submodule changed.

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

@@ -5,6 +5,7 @@ name: fstab

55file_extensions:

66 - fstab

77 - crypttab

8+ - mtab

89scope: source.fstab

910

1011contexts:

assets/syntaxes/02_Extra/GLSL+1−1

Submodule changed.

assets/syntaxes/02_Extra/GraphQL+1−1

Submodule changed.

assets/syntaxes/02_Extra/Groffnew file+1

Submodule changed.

assets/syntaxes/02_Extra/INI.sublime-syntax+2−2

@@ -5,8 +5,8 @@ name: INI

55file_extensions:

66 - ini

77 - INI

8− - inf

9− - INF

8+ - "inf"

9+ - "INF"

1010 - reg

1111 - REG

1212 - lng

assets/syntaxes/02_Extra/Julia+1−1

Submodule changed.

assets/syntaxes/02_Extra/LESS+1−1

Submodule changed.

assets/syntaxes/02_Extra/LLVMnew file+1

Submodule changed.

assets/syntaxes/02_Extra/Leannew file+1

Submodule changed.

assets/syntaxes/02_Extra/Lean.sublime-syntaxnew file+125

@@ -0,0 +1,125 @@

1+%YAML 1.2

2+---

3+# http://www.sublimetext.com/docs/3/syntax.html

4+name: Lean

5+file_extensions:

6+ - lean

7+scope: source.lean

8+contexts:

9+ main:

10+ - include: comments

11+ - match: '\b(?<!\.)(inductive|coinductive|structure|theorem|axiom|axioms|abbreviation|lemma|definition|def|instance|class|constant)\b\s+(\{[^}]*\})?'

12+ captures:

13+ 1: keyword.other.definitioncommand.lean

14+ push:

15+ - meta_scope: meta.definitioncommand.lean

16+ - match: '(?=\bwith\b|\bextends\b|[:\|\(\[\{⦃<>])'

17+ pop: true

18+ - include: comments

19+ - include: definitionName

20+ - match: ","

21+ - match: \b(Prop|Type|Sort)\b

22+ scope: storage.type.lean

23+ - match: '\battribute\b\s*\[[^\]]*\]'

24+ scope: storage.modifier.lean

25+ - match: '@\[[^\]]*\]'

26+ scope: storage.modifier.lean

27+ - match: \b(?<!\.)(private|meta|mutual|protected|noncomputable)\b

28+ scope: keyword.control.definition.modifier.lean

29+ - match: \b(sorry)\b

30+ scope: invalid.illegal.lean

32+ scope: keyword.other.command.lean

34+ scope: keyword.other.command.lean

36+ scope: keyword.other.lean

38+ scope: keyword.other.lean

39+ - match: «

40+ push:

41+ - meta_content_scope: entity.name.lean

42+ - match: »

43+ pop: true

44+ - match: \b(?<!\.)(if|then|else)\b

45+ scope: keyword.control.lean

46+ - match: '"'

47+ captures:

48+ 0: punctuation.definition.string.begin.lean

49+ push:

50+ - meta_scope: string.quoted.double.lean

51+ - match: '"'

52+ captures:

53+ 0: punctuation.definition.string.end.lean

54+ pop: true

55+ - match: '\\[\\"nt'']'

56+ scope: constant.character.escape.lean

57+ - match: '\\x[0-9A-Fa-f][0-9A-Fa-f]'

58+ scope: constant.character.escape.lean

59+ - match: '\\u[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]'

60+ scope: constant.character.escape.lean

61+ - match: '''[^\\'']'''

62+ scope: string.quoted.single.lean

63+ - match: '''(\\(x..|u....|.))'''

64+ scope: string.quoted.single.lean

65+ captures:

66+ 1: constant.character.escape.lean

67+ - match: '`+[^\[(]\S+'

68+ scope: entity.name.lean

69+ - match: '\b([0-9]+|0([xX][0-9a-fA-F]+))\b'

70+ scope: constant.numeric.lean

71+ blockComment:

72+ - match: /-

73+ push:

74+ - meta_scope: comment.block.lean

75+ - match: "-/"

76+ pop: true

77+ - include: scope:source.lean.markdown

78+ - include: blockComment

79+ comments:

80+ - include: dashComment

81+ - include: docComment

82+ - include: stringBlock

83+ - include: modDocComment

84+ - include: blockComment

85+ dashComment:

86+ - match: (--)

87+ captures:

88+ 0: punctuation.definition.comment.lean

89+ push:

90+ - meta_scope: comment.line.double-dash.lean

91+ - match: $

92+ pop: true

93+ - include: scope:source.lean.markdown

94+ definitionName:

95+ - match: '\b[^:«»\{\}[:space:]=→λ∀?][^:«»\{\}[:space:]]*'

96+ scope: entity.name.function.lean

97+ - match: «

98+ push:

99+ - meta_content_scope: entity.name.function.lean

100+ - match: »

101+ pop: true

102+ docComment:

103+ - match: /--

104+ push:

105+ - meta_scope: comment.block.documentation.lean

106+ - match: "-/"

107+ pop: true

108+ - include: scope:source.lean.markdown

109+ - include: blockComment

110+ modDocComment:

111+ - match: /-!

112+ push:

113+ - meta_scope: comment.block.documentation.lean

114+ - match: "-/"

115+ pop: true

116+ - include: scope:source.lean.markdown

117+ - include: blockComment

118+ stringBlock:

119+ - match: /-"

120+ push:

121+ - meta_scope: comment.block.string.lean

122+ - match: '"-/'

123+ pop: true

124+ - include: scope:source.lean.markdown

125+ - include: blockComment

assets/syntaxes/02_Extra/LiveScriptnew file+1

Submodule changed.

assets/syntaxes/02_Extra/LiveScript.sublime-syntaxnew file+400

@@ -0,0 +1,400 @@

1+%YAML 1.2

2+---

3+# http://www.sublimetext.com/docs/3/syntax.html

4+name: LiveScript

5+comment: "LiveScript Syntax: version 1"

6+file_extensions:

7+ - ls

8+ - Slakefile

9+ - ls.erb

10+first_line_match: ^#!.*\bls

11+scope: source.livescript

12+contexts:

13+ main:

14+ - match: |-

15+ (?x)

16+ !?[~-]{1,2}>\*?

17+ |<[~-]{1,2}!?

18+ |\(\s* (?= instanceof[\s)]|and[\s)]|or[\s)]|is[\s)]|isnt[\s)]|in[\s)]|import[\s)]|import\ all[\s)] |\.|[-+/*%^&<>=|][\b\s)\w$]|\*\*|\%\%)

19+ | (?<=[\s(]instanceof|[\s(]and|[\s(]or|[\s(]is|[\s(]isnt|[\s(]in|[\s(]import|[\s(]import\ all|[\s(]do|\.|\*\*|\%\%|[\b\s(\w$][-+/*%^&<>=|]) \s*\)

20+ scope: storage.type.function.livescript

21+ - match: \/\*

22+ captures:

23+ 0: punctuation.definition.comment.livescript

24+ push:

25+ - meta_scope: comment.block.livescript

26+ - match: \*\/

27+ captures:

28+ 0: punctuation.definition.comment.livescript

29+ pop: true

30+ - match: '@\w*'

31+ scope: storage.type.annotation.livescriptscript

32+ - match: '(#)(?!\{).*$\n?'

33+ scope: comment.line.number-sign.livescript

34+ captures:

35+ 1: punctuation.definition.comment.livescript

36+ - match: '((?:!|~|!~|~!)?function\*?)\s+([$\w\-]*[$\w]+)'

37+ captures:

38+ 1: storage.type.function.livescript

39+ 2: entity.name.function.livescript

40+ - match: (new)\s+(\w+(?:\.\w*)*)

41+ captures:

42+ 1: keyword.operator.new.livescript

43+ 2: entity.name.type.instance.livescript

45+ scope: keyword.illegal.livescript

46+ - match: "'''"

47+ captures:

48+ 0: punctuation.definition.string.begin.livescript

49+ push:

50+ - meta_scope: string.quoted.heredoc.livescript

51+ - match: "'''"

52+ captures:

53+ 0: punctuation.definition.string.end.livescript

54+ pop: true

55+ - match: '"""'

56+ captures:

57+ 0: punctuation.definition.string.begin.livescript

58+ push:

59+ - meta_scope: string.quoted.double.heredoc.livescript

60+ - match: '"""'

61+ captures:

62+ 0: punctuation.definition.string.end.livescript

63+ pop: true

64+ - match: \\.

65+ scope: constant.character.escape.livescript

66+ - include: interpolated_livescript

67+ - match: "``"

68+ captures:

69+ 0: punctuation.definition.string.begin.livescript

70+ push:

71+ - meta_scope: string.quoted.script.livescript

72+ - match: "``"

73+ captures:

74+ 0: punctuation.definition.string.end.livescript

75+ pop: true

76+ - 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]?|.)'

77+ scope: constant.character.escape.livescript

78+ - match: '<\['

79+ push:

80+ - meta_scope: string.array-literal.livescript

81+ - match: '\]>'

82+ pop: true

83+ - match: '/{2}(?![\s=/*+{}?]).*?[^\\]/[igmy]{0,4}(?![a-zA-Z0-9])/{2}'

84+ scope: string.regexp.livescript

85+ - match: '/{2}\n'

86+ push:

87+ - meta_scope: string.regexp.livescript

88+ - match: "/{2}[imgy]{0,4}"

89+ pop: true

90+ - include: embedded_spaced_comment

91+ - include: interpolated_livescript

92+ - match: "/{2}"

93+ push:

94+ - meta_scope: string.regexp.livescript

95+ - match: "/{2}[imgy]{0,4}"

96+ pop: true

97+ - 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]?|.)'

98+ scope: constant.character.escape.livescript

99+ - include: interpolated_livescript

100+ - match: '/(?![\s=/*+{}?]).*?[^\\]/[igmy]{0,4}(?![a-zA-Z0-9])'

101+ scope: string.regexp.livescript

102+ - match: |-

103+ (?x)

104+ \b(?<![\.\$\-@])(

105+ instanceof|new|delete|typeof|and|or|is|isnt|not

106+ )(?!\-|\s*:)\b

107+ scope: keyword.operator.livescript

108+ - match: <\||\|>

109+ scope: keyword.operator.livescript

110+ - match: "=>"

111+ scope: keyword.control.livescript

112+ - match: |-

113+ (?x)

114+ \b(?<![\.\$\-@])(?:

115+ return|break|continue|throw

116+ |try|if|while|for|for\s+own|switch|unless|until

118+ |yield

119+ )(?!\-|\s*:)\b

120+ scope: keyword.control.livescript

121+ - match: |-

122+ (?x)

123+ and=|or=|%|&|\^|\*|\/|(?<![a-zA-Z$_])(\-)?\-(?!\-?>)|\+\+|\+|

124+ ~(?!~?>)|==|=|!=|<=|>=|<<=|>>=|

125+ >>>=|<>|<(?!\[)|(?<!\])>|(?<!\w)!(?!([~\-]+)?>)|&&|\.\.(\.)?|\s\.\s|\?|\|\||\:|\*=|(?<!\()/=|%=|\+=|\-=|\.=|&=

126+ |\^=

127+ scope: keyword.operator.livescript

128+ - match: |-

129+ (?x)

130+ \b(?<![\.\$\-@])(?:

131+ function

132+ )(?!\-|\s*:)\b

133+ scope: storage.type.function.livescript

134+ - match: |-

135+ (?x)

136+ \b(?<![\.\$\-@])(?:

137+ this|throw|then|try|typeof!?|til|to

139+ |in|instanceof|import|import\s+all|implements|if|is

140+ |default|delete|debugger|do

142+ |super|switch

144+ |and|arguments

145+ |new|not

146+ |unless|until

147+ |while|with|when

148+ |of|or|otherwise

149+ |let|var|loop

150+ |match

151+ |by|yield

152+ )(?!\-|\s*:)\b

153+ scope: keyword.other.livescript

154+ - match: '([a-zA-Z\$_](?:[\w$.-])*)\s*(?!\::)((:)|(=(?!>)))\s*(?!(\s*!?\s*$.*$)?\s*(!?[~-]{1,2}>\*?))'

155+ captures:

156+ 1: variable.assignment.livescript

157+ 3: punctuation.separator.key-value, keyword.operator.livescript

158+ 4: keyword.operator.livescript

159+ - match: '(?<=\s|^)([\[\{])(?=.*?[\]\}]\s+[:=])'

160+ captures:

161+ 0: keyword.operator.livescript

162+ push:

163+ - meta_scope: meta.variable.assignment.destructured.livescript

164+ - match: '([\]\}]\s*[:=])'

165+ captures:

166+ 0: keyword.operator.livescript

167+ pop: true

168+ - include: variable_name

169+ - include: instance_variable

170+ - include: single_quoted_string

171+ - include: double_quoted_string

172+ - include: numeric

173+ - match: |-

174+ (?x)

175+ (\s*)

176+ (?=[a-zA-Z\$_])

177+ ([a-zA-Z\$_]([\w$.:-])*)\s*

178+ (?=[:=](\s*!?\s*$.*$)?\s*(!?[~-]{1,2}>\*?))

179+ scope: meta.function.livescript

180+ captures:

181+ 2: entity.name.function.livescript

182+ 3: entity.name.function.livescript

183+ 4: variable.parameter.function.livescript

184+ 5: storage.type.function.livescript

185+ - match: \b(?<!\.)(true|on|yes)(?!\s*:)\b

186+ scope: constant.language.boolean.true.livescript

187+ - match: \b(?<!\.)(false|off|no)(?!\s*:)\b

188+ scope: constant.language.boolean.false.livescript

189+ - match: \b(?<!\.)(null|void)(?!\s*:)\b

190+ scope: constant.language.null.livescript

191+ - match: \b(?<!\.)(super|this|extends)(?!\s*:)\b

192+ scope: variable.language.livescript

193+ - match: '(class\b)\s+(@?[a-zA-Z$_][\w$.-]*)?(?:\s+(extends)\s+(@?[a-zA-Z$_][\w$.-]*))?'

194+ scope: meta.class.livescript

195+ captures:

196+ 1: storage.type.class.livescript

197+ 2: entity.name.type.class.livescript

198+ 3: keyword.control.inheritance.livescript

199+ 4: entity.other.inherited-class.livescript

200+ - match: \b(debugger|\\)\b

201+ scope: keyword.other.livescript

202+ - match: |-

203+ (?x)\b(

205+ Int(8|16|32|64)Array|Math|Map|Number|

208+ )\b

209+ scope: support.class.livescript

210+ - match: \b(console)\b

211+ scope: entity.name.type.object.livescript

212+ - match: \b(Infinity|NaN|undefined)\b

213+ scope: constant.language.livescript

214+ - match: \;

215+ scope: punctuation.terminator.statement.livescript

216+ - match: ',[ |\t]*'

217+ scope: meta.delimiter.object.comma.livescript

218+ - match: \.

219+ scope: meta.delimiter.method.period.livescript

220+ - match: '\{|\}'

221+ scope: meta.brace.curly.livescript

222+ - match: $|$

223+ scope: meta.brace.round.livescript

224+ - match: '\[|\]\s*'

225+ scope: meta.brace.square.livescript

226+ - include: instance_variable

227+ - include: backslash_string

228+ - include: single_quoted_string

229+ - include: double_quoted_string

230+ - include: numeric

231+ - match: '()(@|@@|[$\w\-]*[$\w]+)\s*(`)'

232+ captures:

233+ 1: keyword.operator.livescript

234+ 2: meta.function-call.livescript

235+ 3: keyword.operator.livescript

236+ - match: "`"

237+ scope: keyword.operator.livescript

238+ - match: '()(@|@@|[$\w\-]*[$\w]+)(?:(\??\!)|[(])'

239+ captures:

240+ 1: keyword.operator.livescript

241+ 2: meta.function-call.livescript

242+ 3: keyword.operator.livescript

243+ - 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|\#|/\*))'

244+ captures:

245+ 1: meta.function-call.livescript

246+ 2: keyword.operator.livescript

247+ - match: \| _

248+ scope: keyword.control.livescript

249+ - match: '\|(?![.])'

250+ scope: keyword.control.livescript

251+ - match: \|

252+ scope: keyword.operator.livescript

254+ scope: support.function.console.livescript

255+ - match: |-

256+ (?x)\b(

258+ )\b

259+ scope: support.function.livescript

260+ - match: |-

261+ (?x)(?<![.-])\b(

270+ sort(With|-with|By|-by)?|group(By|-by)|break(List|-list|Str|-str)|

272+ lines|unlines|words|unwords|max|min|negate|abs|signum|quot|rem|div|mod|

273+ recip|pi|tau|exp|sqrt|ln|pow|sin|cos|tan|asin|acos|atan|atan2|truncate|

275+ )\b(?![.-])

276+ comment: |

277+ Generated by DOM query from http://gkz.github.com/prelude-ls/:

278+ [].slice

279+ .call(document.querySelectorAll(".nav-pills li a"))

280+ .map(function(_) {return _.innerText})

281+ .filter(function(_) {return _.trim() !== '})

282+ .slice(2)

283+ .join("|")

284+ scope: support.function.prelude.livescript

285+ - match: '(?x)(?<![.-])\b(that|it|e|_)\b'

286+ scope: support.function.semireserved.livescript

287+ - match: |-

288+ (?x)((?<=(\.|\]|\)))(

292+ map|of|pop|property(Is|-is)(Enumerable|-enumerable)|push|

295+ ))\b(?!-)

296+ scope: support.function.method.array.livescript

297+ - match: |-

298+ (?x)((?<=Array\.)(

299+ isArray

300+ ))\b

301+ scope: support.function.static.array.livescript

302+ - match: |-

303+ (?x)((?<=Object\.)(

305+ get(Own|-own)(Property|-property)(Descriptors?|Names)|

306+ get(Property|-property)(Descriptor|Names)|getPrototypeOf|

308+ keys|prevent(Extensions|-extensions)|seal

309+ ))\b

310+ scope: support.function.static.object.livescript

311+ - match: |-

312+ (?x)((?<=Math\.)(

314+ hypot|log|log10|log1p|log2|max|min|pow|random|round|sign|sin|sinh|sqrt|

315+ tan|tanh|trunc

316+ ))\b

317+ scope: support.function.static.math.livescript

318+ - match: |-

319+ (?x)((?<=Number\.)(

320+ is(Finite|Integer|NaN)|to(Integer|-integer)

321+ ))\b

322+ scope: support.function.static.number.livescript

323+ - match: '[\$\w][\w-]*'

324+ scope: variable.other.livescript

325+ backslash_string:

326+ - match: '\$[\$\s,\};\]])?'

327+ captures:

328+ 0: string.quoted.single.livescript

329+ push:

330+ - meta_content_scope: string.quoted.single.livescript

331+ - match: '([\\)\s,\};\]])'

332+ captures:

333+ 0: punctuation.definition.string.end.livescript

334+ pop: true

335+ constructor_variable:

336+ - match: '([a-zA-Z$_][\w$-]*)(@{2})([a-zA-Z$_][\w$-]*)?'

337+ scope: variable.other.readwrite.constructor.livescript

338+ double_quoted_string:

339+ - match: '"'

340+ captures:

341+ 0: punctuation.definition.string.begin.livescript

342+ push:

343+ - meta_scope: string.quoted.double.livescript

344+ - match: '"'

345+ captures:

346+ 0: punctuation.definition.string.end.livescript

347+ pop: true

348+ - 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]?|.)'

349+ scope: constant.character.escape.livescript

350+ - include: interpolated_livescript

351+ embedded_comment:

352+ - match: (?<!\\)(#).*$\n

353+ scope: comment.line.number-sign.livescript

354+ captures:

355+ 1: punctuation.definition.comment.livescript

356+ embedded_spaced_comment:

357+ - match: (?<!\\)(#\s).*$\n

358+ scope: comment.line.number-sign.livescript

359+ captures:

360+ 1: punctuation.definition.comment.livescript

361+ instance_variable:

362+ - match: '(?<![$\w\-])(@)'

363+ scope: variable.other.readwrite.instance.livescript

364+ interpolated_livescript:

365+ - match: '\#\{'

366+ captures:

367+ 0: punctuation.section.embedded.livescript

368+ push:

369+ - meta_scope: source.livescript.embedded.source

370+ - match: '\}'

371+ captures:

372+ 0: punctuation.section.embedded.livescript

373+ pop: true

374+ - include: main

375+ - match: '\#'

376+ push:

377+ - meta_scope: source.livescript.embedded.source.simple

378+ - match: ""

379+ pop: true

380+ - include: main

381+ numeric:

382+ - 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]*)'

383+ scope: constant.numeric.livescript

384+ single_quoted_string:

385+ - match: "'"

386+ captures:

387+ 0: punctuation.definition.string.begin.livescript

388+ push:

389+ - meta_scope: string.quoted.single.livescript

390+ - match: "'"

391+ captures:

392+ 0: punctuation.definition.string.end.livescript

393+ pop: true

394+ - 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]?|.)'

395+ scope: constant.character.escape.livescript

396+ variable_name:

397+ - match: '([a-zA-Z\$_][\w$-]*(\.\w+)*)(?!\-)'

398+ scope: variable.assignment.livescript

399+ captures:

400+ 1: variable.assignment.livescript

assets/syntaxes/02_Extra/Manpage.sublime-syntax+12−4

@@ -59,12 +59,19 @@ contexts:

5959 escape: '(?={{section_heading}})'

6060

6161 function-call:

62− - match: '\b([A-Za-z0-9_\-]+)($)([^)]*)($)'

62+ - match: '\b([A-Za-z0-9_\-]+\.)?([A-Za-z0-9_\-]+)($)([^)]*)($)'

6363 captures:

6464 1: entity.name.function.man

65− 2: keyword.operator.man

66− 3: constant.numeric.man

67− 4: keyword.operator.man

65+ 2: entity.name.function.man

66+ 3: keyword.operator.man

67+ 4: constant.numeric.man

68+ 5: keyword.operator.man

69+

70+ env-var:

71+ - match: '(\$)(?!\d)(\w+)\b'

72+ captures:

73+ 1: punctuation.definition.variable.man

74+ 2: constant.other.man

6875

6976 options:

7077 # command-line options like --option=value, --some-flag, or -x

@@ -86,6 +93,7 @@ contexts:

8693 pop: true

8794 - include: function-call

8895 - include: c-code

96+ - include: env-var

8997

9098 expect-command-line-option:

9199 - match: '[A-Za-z0-9-]+'

assets/syntaxes/02_Extra/MediaWikinew file+1

Submodule changed.

assets/syntaxes/02_Extra/Nginx+1−1

Submodule changed.

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

@@ -5,6 +5,7 @@ name: Nim

55file_extensions:

66 - nim

77 - nims

8+ - nimble

89scope: source.nim

910contexts:

1011 main:

assets/syntaxes/02_Extra/PowerShell+1−1

Submodule changed.

assets/syntaxes/02_Extra/PowerShell.sublime-syntax+58−48

@@ -24,7 +24,7 @@ contexts:

2424 - include: commands

2525 - include: commentLine

2626 - include: variable

27− - include: interpolatedStringContent

27+ - include: subexpression

2828 - include: function

2929 - include: attribute

3030 - include: UsingDirective

@@ -33,32 +33,38 @@ contexts:

3333 - include: doubleQuotedString

3434 - include: scriptblock

3535 - include: doubleQuotedStringEscapes

36− - match: (?<!')'

36+ - match: '[''\x{2018}-\x{201B}]'

3737 captures:

3838 0: punctuation.definition.string.begin.powershell

3939 push:

4040 - meta_scope: string.quoted.single.powershell

41− - match: "'(?!')"

41+ - match: '[''\x{2018}-\x{201B}]{2}'

42+ scope: constant.character.escape.powershell

43+ - match: '[''\x{2018}-\x{201B}]'

4244 captures:

4345 0: punctuation.definition.string.end.powershell

4446 pop: true

45− - match: "''"

46− scope: constant.character.escape.powershell

47− - match: \@"(?=$)

47+ - match: '(@["\x{201C}-\x{201E}])\s*$'

48+ captures:

49+ 1: punctuation.definition.string.begin.powershell

4850 push:

4951 - meta_scope: string.quoted.double.heredoc.powershell

50− - match: ^"@

52+ - match: '^["\x{201C}-\x{201E}]@'

53+ captures:

54+ 0: punctuation.definition.string.end.powershell

5155 pop: true

5256 - include: variableNoProperty

5357 - include: doubleQuotedStringEscapes

5458 - include: interpolation

55− - match: \@'(?=$)

59+ - match: '(@[''\x{2018}-\x{201B}])\s*$'

60+ captures:

61+ 1: punctuation.definition.string.begin.powershell

5662 push:

5763 - meta_scope: string.quoted.single.heredoc.powershell

58− - match: ^'@

64+ - match: '^[''\x{2018}-\x{201B}]@'

65+ captures:

66+ 0: punctuation.definition.string.end.powershell

5967 pop: true

60− - match: "''"

61− scope: constant.character.escape.powershell

6268 - include: numericConstant

6369 - match: (@)(\()

6470 captures:

@@ -71,11 +77,12 @@ contexts:

7177 0: punctuation.section.group.end.powershell

7278 pop: true

7379 - include: main

74− - match: (\$)(\()

80+ - match: ((\$))(\()

7581 comment: "TODO: move to repo; make recursive."

7682 captures:

77− 1: punctuation.definition.variable.powershell

78− 2: punctuation.section.group.begin.powershell

83+ 1: keyword.other.substatement.powershell

84+ 2: punctuation.definition.subexpression.powershell

85+ 3: punctuation.section.group.begin.powershell

7986 push:

8087 - meta_scope: meta.group.complex.subexpression.powershell

8188 - match: \)

@@ -85,7 +92,7 @@ contexts:

8592 - include: main

8693 - match: '(\b(([A-Za-z0-9\-_\.]+)\.(?i:exe|com|cmd|bat))\b)'

8794 scope: support.function.powershell

8996 scope: keyword.control.powershell

9097 - match: '(?<!\w|-|[^\)]\.)((?i:(foreach|where)(?!-object))|%|\?)(?!\w)'

9198 scope: keyword.control.powershell

@@ -135,7 +142,7 @@ contexts:

135142 - meta_scope: meta.requires.powershell

136143 - match: $

137144 pop: true

138− - match: \-(?i:Modules|PSSnapin|RunAsAdministrator|ShellId|Version)

139146 scope: keyword.other.powershell

140147 - match: '(?<!-)\b\p{L}+|\d+(?:\.\d+)*'

141148 scope: variable.parameter.powershell

@@ -187,51 +194,53 @@ contexts:

187194 comment: Builtin cmdlets with reserved verbs

188195 scope: support.function.powershell

189196 commentEmbeddedDocs:

198+ comment: these embedded doc keywords do not support arguments, must be the only thing on the line

191199 scope: comment.documentation.embedded.powershell

192200 captures:

193201 1: constant.string.documentation.powershell

194202 2: keyword.operator.documentation.powershell

195− - match: '(?i:\s?(\.)(PARAMETER|FORWARDHELPTARGETNAME|FORWARDHELPCATEGORY|REMOTEHELPRUNSPACE|EXTERNALHELP)\s+([a-z0-9-_]+))'

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

196205 scope: comment.documentation.embedded.powershell

197206 captures:

198207 1: constant.string.documentation.powershell

199208 2: keyword.operator.documentation.powershell

200209 3: keyword.operator.documentation.powershell

201210 commentLine:

202− - match: '(?<![`\\-])#'

211+ - match: '(?<![`\\-])(#)#*'

203212 captures:

204− 0: punctuation.definition.comment.powershell

213+ 1: punctuation.definition.comment.powershell

205214 push:

206215 - meta_scope: comment.line.powershell

207216 - match: $\n?

208217 captures:

209− 0: punctuation.definition.comment.powershell

218+ 1: punctuation.definition.comment.powershell

210219 pop: true

211220 - include: commentEmbeddedDocs

212221 - include: RequiresDirective

213222 doubleQuotedString:

214− - match: (?<!(?<!`)")"

223+ - match: '["\x{201C}-\x{201E}]'

215224 captures:

216225 0: punctuation.definition.string.begin.powershell

217226 push:

218227 - meta_scope: string.quoted.double.powershell

219− - match: '"(?!")'

220− captures:

221− 0: punctuation.definition.string.end.powershell

222− pop: true

223228 - match: '(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,64}\b'

224229 - include: variableNoProperty

225230 - include: doubleQuotedStringEscapes

231+ - match: '["\x{201C}-\x{201E}]{2}'

232+ scope: constant.character.escape.powershell

226233 - include: interpolation

227234 - match: '`\s*$'

228235 scope: keyword.other.powershell

236+ - match: '["\x{201C}-\x{201E}]'

237+ captures:

238+ 0: punctuation.definition.string.end.powershell

239+ pop: true

229240 doubleQuotedStringEscapes:

230− - match: '`[`0abefnrtv"''$]'

241+ - match: '`[`0abefnrtv''"\x{2018}-\x{201E}$]'

231242 scope: constant.character.escape.powershell

232243 - include: unicodeEscape

233− - match: '""'

234− scope: constant.character.escape.powershell

235244 function:

236245 - match: '^(?:\s*+)(?i)(function|filter|configuration|workflow)\s+(?:(global|local|script|private):)?((?:\p{L}|\d|_|-|\.)+)'

237246 captures:

@@ -263,33 +272,23 @@ contexts:

263272 4: keyword.operator.assignment.powershell

264273 - include: scriptblock

265274 - include: main

266− interpolatedStringContent:

267− - match: \(

268− captures:

269− 0: punctuation.section.group.begin.powershell

270− push:

271− - meta_content_scope: interpolated.simple.source.powershell

272− - match: \)

273− captures:

274− 0: punctuation.section.group.end.powershell

275− pop: true

276− - include: main

277− - include: interpolation

278− - include: interpolatedStringContent

279275 interpolation:

280− - match: (\$)(\()

276+ - match: (((\$)))((\())

281277 captures:

282− 1: punctuation.definition.variable.powershell

283− 2: punctuation.section.group.begin.powershell

278+ 1: keyword.other.substatement.powershell

279+ 2: punctuation.definition.substatement.powershell

280+ 3: punctuation.section.embedded.substatement.begin.powershell

281+ 4: punctuation.section.group.begin.powershell

282+ 5: punctuation.section.embedded.substatement.begin.powershell

284283 push:

284+ - meta_scope: meta.embedded.substatement.powershell

285285 - meta_content_scope: interpolated.complex.source.powershell

286− - match: \)

286+ - match: (\))

287287 captures:

288288 0: punctuation.section.group.end.powershell

289+ 1: punctuation.section.embedded.substatement.end.powershell

289290 pop: true

290291 - include: main

291− - include: interpolation

292− - include: interpolatedStringContent

293292 numericConstant:

294293 - 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'

295294 captures:

@@ -330,6 +329,17 @@ contexts:

330329 0: punctuation.section.braces.end.powershell

331330 pop: true

332331 - include: main

332+ subexpression:

333+ - match: \(

334+ captures:

335+ 0: punctuation.section.group.begin.powershell

336+ push:

337+ - meta_scope: meta.group.simple.subexpression.powershell

338+ - match: \)

339+ captures:

340+ 0: punctuation.section.group.end.powershell

341+ pop: true

342+ - include: main

333343 type:

334344 - match: '\['

335345 captures:

assets/syntaxes/02_Extra/Racketnew file+1

Submodule changed.

assets/syntaxes/02_Extra/Racket.sublime-syntaxnew file+52

@@ -0,0 +1,52 @@

1+%YAML 1.2

2+---

3+# http://www.sublimetext.com/docs/3/syntax.html

4+name: Racket

5+file_extensions:

6+ - rkt

7+scope: source.racket

8+contexts:

9+ main:

10+ - match: '[^\\](\"[^\"]*\")'

11+ captures:

12+ 1: string.quoted.double.source.racket

13+ - match: '\((define)\s+([a-zA-Z0-9_\-?\+^]+)\s*'

14+ scope: meta.variable.source.racket

15+ captures:

16+ 1: keyword.source.racket

17+ 2: entity.name.variable.source.racket

18+ - match: '\((define)\s+\(([a-zA-Z0-9_\-?\+^]+)\s*'

19+ scope: meta.function.source.racket

20+ captures:

21+ 1: keyword.source.racket

22+ 2: entity.name.function

23+ - match: '\((struct)\s+([a-zA-Z0-9_\-?\+^]+)\s+'

24+ scope: meta.struct.source.racket

25+ captures:

26+ 1: keyword.source.racket

27+ 2: entity.name.type

29+ scope: meta.keywords.source.racket

30+ captures:

31+ 1: keyword.source.racket

32+ - match: '[\s$](true|false|empty|null)[\s$]'

33+ captures:

34+ 1: constant.language.source.racket

35+ - match: '[\s$\[\{](#t|#true|#f|#false)[\s$\]\}]'

36+ captures:

37+ 1: constant.language.source.racket

38+ - match: '(#\\[a-zA-Z0-9_\-?\+\.\!\"]+)'

39+ captures:

40+ 1: constant.language.source.racket

41+ - match: '\b(0|([1-9][0-9_]*))\b'

42+ scope: constant.numeric.integer.source.racket

43+ - match: ;

44+ push:

45+ - meta_scope: comment.line.documentation.source.racket

46+ - match: $\n

47+ pop: true

48+ - match: '#\|'

49+ push:

50+ - meta_scope: comment.block.source.racket

51+ - match: '\|#'

52+ pop: true

assets/syntaxes/02_Extra/Robot.sublime-syntax+1

@@ -4,6 +4,7 @@

44name: Robot Framework

55file_extensions:

66 - robot

7+ - resource

78scope: source.robot

89contexts:

910 main:

assets/syntaxes/02_Extra/SCSS_Sass+1−1

Submodule changed.

assets/syntaxes/02_Extra/Slimnew file+1

Submodule changed.

assets/syntaxes/02_Extra/Slim.sublime-syntaxnew file+306

@@ -0,0 +1,306 @@

1+%YAML 1.2

2+---

3+# http://www.sublimetext.com/docs/syntax.html

4+name: Ruby Slim

5+file_extensions:

6+ - slim

7+ - skim

8+scope: text.slim

9+contexts:

10+ main:

11+ - match: ^(\s*)(ruby):$

12+ captures:

13+ 2: constant.language.name.ruby.filter.slim

14+ push:

15+ - meta_scope: text.ruby.filter.slim

16+ - match: ^(?!(\1\s)|\s*$)

17+ pop: true

18+ - include: scope:source.ruby

19+ - match: ^(\s*)(javascript):$

20+ captures:

21+ 2: constant.language.name.javascript.filter.slim

22+ push:

23+ - meta_scope: source.js.filter.slim

24+ - match: ^(?!(\1\s)|\s*$)

25+ pop: true

26+ - include: scope:source.js

27+ - match: ^(---)\s*\n

28+ captures:

29+ 1: storage.frontmatter.slim

30+ push:

31+ - meta_scope: source.yaml.meta.slim

32+ - match: ^(---)\s*\n

33+ captures:

34+ 1: storage.frontmatter.slim

35+ pop: true

36+ - include: scope:source.yaml

37+ - match: ^(\s*)(coffee):$

38+ captures:

39+ 2: constant.language.name.coffeescript.filter.slim

40+ push:

41+ - meta_scope: text.coffeescript.filter.slim

42+ - match: ^(?!(\1\s)|\s*$)

43+ pop: true

44+ - include: scope:source.coffee

45+ - match: ^(\s*)(markdown):$

46+ captures:

47+ 2: constant.language.name.markdown.filter.slim

48+ push:

49+ - meta_scope: text.markdown.filter.slim

50+ - match: ^(?!(\1\s)|\s*$)

51+ pop: true

52+ - include: scope:text.html.markdown

53+ - match: ^(\s*)(css):$

54+ captures:

55+ 2: constant.language.name.css.filter.slim

56+ push:

57+ - meta_scope: text.css.filter.slim

58+ - match: ^(?!(\1\s)|\s*$)

59+ pop: true

60+ - include: scope:source.css

61+ - match: ^(\s*)(sass):$

62+ captures:

63+ 2: constant.language.name.sass.filter.slim

64+ push:

65+ - meta_scope: text.sass.filter.slim

66+ - match: ^(?!(\1\s)|\s*$)

67+ pop: true

68+ - include: scope:source.sass

69+ - match: ^(\s*)(scss):$

70+ captures:

71+ 2: constant.language.name.scss.filter.slim

72+ push:

73+ - meta_scope: text.scss.filter.slim

74+ - match: ^(?!(\1\s)|\s*$)

75+ pop: true

76+ - include: scope:source.scss

77+ - match: ^(\s*)(less):$

78+ captures:

79+ 2: constant.language.name.less.filter.slim

80+ push:

81+ - meta_scope: text.less.filter.slim

82+ - match: ^(?!(\1\s)|\s*$)

83+ pop: true

84+ - include: scope:source.less

85+ - match: ^(\s*)(erb):$

86+ captures:

87+ 2: constant.language.name.erb.filter.slim

88+ push:

89+ - meta_scope: text.erb.filter.slim

90+ - match: ^(?!(\1\s)|\s*$)

91+ pop: true

92+ - include: scope:source.erb

93+ - match: ^(! )($|\s.*)

94+ scope: meta.prolog.slim

95+ captures:

96+ 1: punctuation.definition.prolog.slim

97+ - match: ^(\s*)(/)\s*.*$

98+ captures:

99+ 2: comment.line.slash.slim

100+ push:

101+ - meta_scope: comment.block.slim

102+ - match: ^(?!(\1\s)|\s*$)

103+ pop: true

104+ - match: ^\s*(?=-)

105+ push:

106+ - match: $

107+ pop: true

108+ - include: rubyline

109+ - match: (?==+|~)

110+ push:

111+ - match: $

112+ pop: true

113+ - include: rubyline

114+ - include: tag-attribute

115+ - include: embedded-ruby

116+ - match: ^(\s*)(\||')\s*

117+ comment: Verbatim text (can include HTML tags and copied lines)

118+ push:

119+ - match: ^(?!(\1\s)|\s*$)

120+ pop: true

121+ - include: scope:text.html.basic

122+ - include: embedded-ruby

123+ - match: '^\s*(\.|#|[-a-zA-Z0-9]+)([\w-]+)?'

124+ comment: '1 - dot OR hash OR any combination of word, number; 2 - OPTIONAL any combination of word, number, dash or underscore (following a . or'

125+ captures:

126+ 1: entity.name.tag.slim

127+ 2: entity.other.attribute-name.event.slim

128+ push:

129+ - meta_scope: meta.tag

130+ - match: '$|(?!\.|#|:|-|~|/|\}|\]|\*|\s?[\*\{])'

131+ captures:

132+ 1: entity.name.tag.slim

133+ 2: entity.other.attribute-name.event.slim

134+ pop: true

135+ - match: '(:[\w\d]+)+'

136+ comment: XML

137+ push:

138+ - meta_scope: entity.name.tag.slim

139+ - match: $|\s

140+ pop: true

141+ - match: '(:\s)(\.|#|[a-zA-Z0-9]+)([\w-]+)?'

142+ comment: Inline HTML / 1 - colon; 2 - dot OR hash OR any combination of word, number; 3 - OPTIONAL any combination of word, number, dash or underscore (following a . or

143+ captures:

144+ 1: punctuation.definition.tag.end.slim

145+ 2: entity.name.tag.slim

146+ 3: entity.other.attribute-name.event.slim

147+ push:

148+ - match: '$|(?!\.|#|=|-|~|/|\}|\]|\*|\s?[\*\{])'

149+ captures:

150+ 1: punctuation.definition.tag.end.slim

151+ 2: entity.name.tag.slim

152+ 3: entity.other.attribute-name.event.slim

153+ pop: true

154+ - include: root-class-id-tag

155+ - include: tag-attribute

156+ - match: '(\*\{)(?=.*\}|.*\|\s*$)'

157+ comment: Splat attributes

158+ captures:

159+ 1: punctuation.section.embedded.ruby

160+ push:

161+ - meta_scope: source.ruby.embedded.slim

162+ - match: '(\})|$|^(?!.*\|\s*$)'

163+ captures:

164+ 1: punctuation.section.embedded.ruby

165+ pop: true

166+ - include: embedded-ruby

167+ - include: root-class-id-tag

168+ - include: rubyline

169+ - match: /

170+ scope: punctuation.terminator.tag.slim

171+ - match: ^\s*(\\.)

172+ captures:

173+ 1: meta.escape.slim

174+ - match: ^\s*(?=\||')

175+ push:

176+ - match: $

177+ pop: true

178+ - include: embedded-ruby

179+ - include: scope:text.html.basic

180+ - match: '(?=<[\w\d\:]+)'

181+ comment: Inline and root-level HTML tags

182+ push:

183+ - match: $|\/\>

184+ pop: true

185+ - include: scope:text.html.basic

186+ continuation:

187+ - match: '([\\,])\s*\n'

188+ captures:

189+ 1: punctuation.separator.continuation.slim

190+ delimited-ruby-a:

191+ - match: '=\('

192+ push:

193+ - meta_scope: source.ruby.embedded.slim

194+ - match: \)(?=( \w|$))

195+ pop: true

196+ - include: scope:source.ruby.rails

197+ delimited-ruby-b:

198+ - match: '=\['

199+ push:

200+ - meta_scope: source.ruby.embedded.slim

201+ - match: '\](?=( \w|$))'

202+ pop: true

203+ - include: scope:source.ruby.rails

204+ delimited-ruby-c:

205+ - match: '=\{'

206+ push:

207+ - meta_scope: source.ruby.embedded.slim

208+ - match: '\}(?=( \w|$))'

209+ pop: true

210+ - include: scope:source.ruby.rails

211+ embedded-ruby:

212+ - match: '(?<!\\)#\{{1,2}'

213+ captures:

214+ 0: punctuation.section.embedded.ruby

215+ push:

216+ - meta_scope: source.ruby.embedded.html

217+ - match: '\}{1,2}'

218+ captures:

219+ 0: punctuation.section.embedded.ruby

220+ pop: true

221+ - include: scope:source.ruby.rails

222+ entities:

223+ - match: '(&)([a-zA-Z0-9]+|#[0-9]+|#x[0-9a-fA-F]+)(;)'

224+ scope: constant.character.entity.html

225+ captures:

226+ 1: punctuation.definition.entity.html

227+ 3: punctuation.definition.entity.html

228+ - match: '&'

229+ scope: invalid.illegal.bad-ampersand.html

230+ interpolated-ruby:

231+ - match: '=(?=\b)'

232+ push:

233+ - meta_scope: source.ruby.embedded.html

234+ - match: \s|\w$

235+ pop: true

236+ root-class-id-tag:

237+ - match: '(\.|#)([\w\d\-]+)'

238+ captures:

239+ 1: punctuation.separator.key-value.html

240+ 2: entity.other.attribute-name.html

241+ rubyline:

242+ - match: (==|=)(<>|><|<'|'<|<|>)?|-

243+ comment: Hack to thwart Sublime's Ruby highlighter. It thinks do without a variable continues the next line (this can be muted with a / at the end of the line). For things like yields, do is unnecessary without an argument, so this hack will suffice

244+ push:

245+ - meta_scope: meta.line.ruby.slim

246+ - meta_content_scope: source.ruby.embedded.slim

247+ - match: (do\s*\n$)|(?<!\\|,|,\n|\\\n)$

248+ captures:

249+ 1: keyword.control.start-block.ruby

250+ pop: true

251+ - match: '#.*$'

252+ comment: Hack to let ruby comments work in this context properly

253+ scope: comment.line.number-sign.ruby

254+ - include: continuation

255+ - include: scope:source.ruby.rails

256+ string-double-quoted:

257+ - match: (")(?=.*")

258+ captures:

259+ 0: punctuation.definition.string.begin.html

260+ push:

261+ - meta_scope: string.quoted.double.html

262+ - meta_content_scope: meta.toc-list.id.html

263+ - match: '"'

264+ captures:

265+ 0: punctuation.definition.string.end.html

266+ pop: true

267+ - include: embedded-ruby

268+ - include: entities

269+ string-single-quoted:

270+ - match: (')(?=.*')

271+ captures:

272+ 0: punctuation.definition.string.begin.html

273+ push:

274+ - meta_scope: string.quoted.single.html

275+ - meta_content_scope: meta.toc-list.id.html

276+ - match: "'"

277+ captures:

278+ 0: punctuation.definition.string.end.html

279+ pop: true

280+ - include: embedded-ruby

281+ - include: entities

282+ tag-attribute:

283+ - match: '([\w.#_-]+)(=)(?!\s)(true|false|nil)?(\s*\(|\{)?'

284+ captures:

285+ 1: entity.other.attribute-name.event.slim

286+ 2: punctuation.separator.key-value.html

287+ 3: constant.language.slim

288+ push:

289+ - meta_scope: meta.attribute-with-value.slim

290+ - match: '\}|\)|$'

291+ captures:

292+ 1: entity.other.attribute-name.event.slim

293+ 2: punctuation.separator.key-value.html

294+ 3: constant.language.slim

295+ pop: true

296+ - include: tag-stuff

297+ - include: string-double-quoted

298+ - include: string-single-quoted

299+ tag-stuff:

300+ - include: tag-attribute

301+ - include: interpolated-ruby

302+ - include: delimited-ruby-a

303+ - include: delimited-ruby-b

304+ - include: delimited-ruby-c

305+ - include: rubyline

306+ - include: embedded-ruby

assets/syntaxes/02_Extra/Stylus.sublime-syntax+2−2

@@ -197,7 +197,7 @@ contexts:

197197 scope: entity.other.attribute-name.stylus

198198 - match: |-

199199 (?x) # multi-line regex definition mode

200− (?<=^|;|{)\s* # starts after begining of line, '{' or ';''

200+ (?<=^|;|{)\s* # starts after beginning of line, '{' or ';''

201201 (?= # lookahead for

202202 (

203203 [a-zA-Z0-9_-] # then a letter

@@ -207,7 +207,7 @@ contexts:

207207 (/\*.*?\*/) # comment

208208 )+

209209

210− \s*[:\s]\s* # value is separted by colon or space

210+ \s*[:\s]\s* # value is separated by colon or space

211211

212212 (?!(\s*\{)) # if there are only spaces afterwards

213213

assets/syntaxes/02_Extra/SublimeEthereumnew file+1

Submodule changed.

assets/syntaxes/02_Extra/SublimeJQnew file+1

Submodule changed.

assets/syntaxes/02_Extra/Svelte+1−1

Submodule changed.

assets/syntaxes/02_Extra/Syslogdeleted−1

Submodule changed.

assets/syntaxes/02_Extra/SystemVerilognew file+1

Submodule changed.

assets/syntaxes/02_Extra/TOML+1−1

Submodule changed.

assets/syntaxes/02_Extra/TypeScript+1−1

Submodule changed.

assets/syntaxes/02_Extra/TypeScript.sublime-syntax+206−148

@@ -44,7 +44,7 @@ contexts:

4444 - match: (?=$)

4545 pop: true

4646 access-modifier:

4848 scope: storage.modifier.ts

4949 after-operator-block-as-object-literal:

5050 - 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 +106,7 @@ contexts:

106106 (?=

107107 # sure shot arrow functions even if => is on new line

108108 (

109− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

109+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

110110 [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

111111 (

112112 ([)]\s*:) | # ():

@@ -116,9 +116,9 @@ contexts:

116116

117117 # arrow function possible to detect only with => on same line

118118 (

119− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

120− $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($[^\($]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

121− (\s*:\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

119+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

120+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

121+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

122122 \s*=> # arrow operator

123123 )

124124 )

@@ -268,7 +268,7 @@ contexts:

268268 - include: decorator

269269 - match: (?<=:)\s*

270270 push:

271− - match: '(?=\s|[;),}\]:\-\+]|;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

271+ - match: '(?=\s|[;),}\]:\-\+]|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

272272 pop: true

273273 - include: expression

274274 - include: method-declaration

@@ -317,7 +317,12 @@ contexts:

318318 scope: keyword.control.loop.ts

319319 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(return)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

320− scope: keyword.control.flow.ts

320+ captures:

321+ 0: keyword.control.flow.ts

322+ push:

323+ - match: '(?=[;}]|$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

324+ pop: true

325+ - include: expression

321326 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default|switch)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

322327 scope: keyword.control.switch.ts

323328 - include: if-statement

@@ -762,7 +767,7 @@ contexts:

762767 4: keyword.control.default.ts

763768 push:

764769 - meta_scope: meta.export.default.ts

766771 pop: true

767772 - include: interface-declaration

768773 - include: expression

@@ -772,7 +777,7 @@ contexts:

772777 2: keyword.control.type.ts

773778 push:

774779 - meta_scope: meta.export.ts

776781 pop: true

777782 - include: import-export-declaration

778783 expression:

@@ -785,11 +790,11 @@ contexts:

785790 - include: string

786791 - include: decorator

787792 - include: destructuring-parameter

789794 captures:

790795 1: storage.modifier.ts

791796 - match: |-

793798 # function assignment |

794799 (=\s*(

795800 ((async\s+)?(

@@ -798,10 +803,10 @@ contexts:

798803 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

799804 )) |

800805 ((async\s*)?(

801− ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

806+ ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

802807 # sure shot arrow functions even if => is on new line

803808 (

804− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

809+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

805810 [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

806811 (

807812 ([)]\s*:) | # ():

@@ -811,9 +816,9 @@ contexts:

811816

812817 # arrow function possible to detect only with => on same line

813818 (

814− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

815− $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($[^\($]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

816− (\s*:\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

819+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

820+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

821+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

817822 \s*=> # arrow operator

818823 )

819824 ))

@@ -831,18 +836,18 @@ contexts:

831836 ))

832837 )) |

833838 (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |

834− (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

835− (:\s*(=>|($([^\($]|($[^\($]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

839+ (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

840+ (:\s*(=>|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

836841 ((async\s+)?(

837842 (function\s*[(<*]) |

838843 (function\s+) |

839844 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

840845 )) |

841846 ((async\s*)?(

842− ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

847+ ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

843848 # sure shot arrow functions even if => is on new line

844849 (

845− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

850+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

846851 [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

847852 (

848853 ([)]\s*:) | # ():

@@ -852,9 +857,9 @@ contexts:

852857

853858 # arrow function possible to detect only with => on same line

854859 (

855− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

856− $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($[^\($]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

857− (\s*:\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

860+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

861+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

862+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

858863 \s*=> # arrow operator

859864 )

860865 ))

@@ -865,7 +870,7 @@ contexts:

865870 3: entity.name.function.ts variable.language.this.ts

866871 4: entity.name.function.ts

867872 5: keyword.operator.optional.ts

869874 captures:

870875 1: storage.modifier.ts

871876 2: keyword.operator.rest.ts

@@ -930,10 +935,11 @@ contexts:

930935 scope: keyword.operator.comparison.ts

931936 - match: <=|>=|<>|<|>

932937 scope: keyword.operator.relational.ts

933− - match: '(?<=[_$[:alnum:]])(\!)\s*(/)(?![/*])'

938+ - match: '(?<=[_$[:alnum:]])(\!)\s*(?:(/=)|(?:(/)(?![/*])))'

934939 captures:

935940 1: keyword.operator.logical.ts

936− 2: keyword.operator.arithmetic.ts

941+ 2: keyword.operator.assignment.compound.ts

942+ 3: keyword.operator.arithmetic.ts

937943 - match: \!|&&|\|\||\?\?

938944 scope: keyword.operator.logical.ts

939945 - match: \&|~|\^|\|

@@ -946,16 +952,18 @@ contexts:

946952 scope: keyword.operator.increment.ts

947953 - match: '%|\*|/|-|\+'

948954 scope: keyword.operator.arithmetic.ts

949− - match: '(?<=[_$[:alnum:])\]])\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)+(/)(?![/*]))'

955+ - match: '(?<=[_$[:alnum:])\]])\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)+(?:(/=)|(?:(/)(?![/*]))))'

950956 push:

951− - match: '(/)(?!\*([^\*]|(\*[^\/]))*\*\/)'

957+ - match: '(?:(/=)|(?:(/)(?!\*([^\*]|(\*[^\/]))*\*\/)))'

952958 captures:

953− 1: keyword.operator.arithmetic.ts

959+ 1: keyword.operator.assignment.compound.ts

960+ 2: keyword.operator.arithmetic.ts

954961 pop: true

955962 - include: comment

956− - match: '(?<=[_$[:alnum:])\]])\s*(/)(?![/*])'

963+ - match: '(?<=[_$[:alnum:])\]])\s*(?:(/=)|(?:(/)(?![/*])))'

957964 captures:

958− 1: keyword.operator.arithmetic.ts

965+ 1: keyword.operator.assignment.compound.ts

966+ 2: keyword.operator.arithmetic.ts

959967 expressionPunctuations:

960968 - include: punctuation-comma

961969 - include: punctuation-accessor

@@ -1021,10 +1029,10 @@ contexts:

10211029 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

10221030 )) |

10231031 ((async\s*)?(

1024− ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

1032+ ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

10251033 # sure shot arrow functions even if => is on new line

10261034 (

1027− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

1035+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

10281036 [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

10291037 (

10301038 ([)]\s*:) | # ():

@@ -1034,9 +1042,9 @@ contexts:

10341042

10351043 # arrow function possible to detect only with => on same line

10361044 (

1037− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

1038− $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($[^\($]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

1039− (\s*:\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

1045+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

1046+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

1047+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

10401048 \s*=> # arrow operator

10411049 )

10421050 ))

@@ -1054,18 +1062,18 @@ contexts:

10541062 ))

10551063 )) |

10561064 (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |

1057− (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

1058− (:\s*(=>|($([^\($]|($[^\($]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

1065+ (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

1066+ (:\s*(=>|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

10591067 ((async\s+)?(

10601068 (function\s*[(<*]) |

10611069 (function\s+) |

10621070 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

10631071 )) |

10641072 ((async\s*)?(

1065− ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

1073+ ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

10661074 # sure shot arrow functions even if => is on new line

10671075 (

1068− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

1076+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

10691077 [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

10701078 (

10711079 ([)]\s*:) | # ():

@@ -1075,9 +1083,9 @@ contexts:

10751083

10761084 # arrow function possible to detect only with => on same line

10771085 (

1078− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

1079− $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($[^\($]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

1080− (\s*:\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

1086+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

1087+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

1088+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

10811089 \s*=> # arrow operator

10821090 )

10831091 ))

@@ -1118,18 +1126,19 @@ contexts:

11181126 - include: type-parameters

11191127 - include: function-parameters

11201128 - include: return-type

1129+ - include: type-function-return-type

11211130 - include: decl-block

11221131 - match: \*

11231132 scope: keyword.generator.asterisk.ts

11241133 function-call:

1125− - 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*)?\())'

1134+ - 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*)?\())'

11261135 push:

1127− - 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*)?\())'

1136+ - 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*)?\())'

11281137 pop: true

11291138 - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))'

11301139 push:

11311140 - meta_scope: meta.function-call.ts

1132− - 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*)?\())'

1141+ - 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*)?\())'

11331142 pop: true

11341143 - include: function-call-target

11351144 - include: comment

@@ -1169,7 +1178,7 @@ contexts:

11691178 6: meta.definition.function.ts entity.name.function.ts

11701179 push:

11711180 - meta_scope: meta.function.ts

1172− - match: '(?=;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))|(?<=\})'

1181+ - match: '(?=;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))|(?<=\})'

11731182 pop: true

11741183 - include: function-name

11751184 - include: function-body

@@ -1221,10 +1230,10 @@ contexts:

12211230 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

12221231 )) |

12231232 ((async\s*)?(

1224− ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

1233+ ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

12251234 # sure shot arrow functions even if => is on new line

12261235 (

1227− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

1236+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

12281237 [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

12291238 (

12301239 ([)]\s*:) | # ():

@@ -1234,9 +1243,9 @@ contexts:

12341243

12351244 # arrow function possible to detect only with => on same line

12361245 (

1237− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

1238− $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($[^\($]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

1239− (\s*:\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

1246+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

1247+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

1248+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

12401249 \s*=> # arrow operator

12411250 )

12421251 ))

@@ -1260,7 +1269,7 @@ contexts:

12601269 - match: "[_$[:alpha:]][_$[:alnum:]]*"

12611270 scope: variable.other.readwrite.ts

12621271 if-statement:

1263− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bif\s*($([^\($]|($[^\($]*\)))*\))\s*(?!\{))'

1272+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bif\s*($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))\s*(?!\{))'

12641273 push:

12651274 - match: '(?=;|$|\})'

12661275 pop: true

@@ -1275,12 +1284,12 @@ contexts:

12751284 0: meta.brace.round.ts

12761285 pop: true

12771286 - include: expression

1278− - match: '(?<=\))\s*\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/([gimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'

1287+ - match: '(?<=\))\s*\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'

12791288 captures:

12801289 0: punctuation.definition.string.begin.ts

12811290 push:

12821291 - meta_scope: string.regexp.ts

1283− - match: "(/)([gimsuy]*)"

1292+ - match: "(/)([dgimsuy]*)"

12841293 captures:

12851294 1: punctuation.definition.string.end.ts

12861295 2: keyword.other.ts

@@ -1414,6 +1423,9 @@ contexts:

14141423 2: keyword.operator.type.modifier.ts

14151424 3: keyword.operator.optional.ts

14161425 pop: true

1426+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+'

1427+ captures:

1428+ 1: keyword.control.as.ts

14171429 - include: type

14181430 inline-tags:

14191431 - match: '(\[)[^\]]+(\])(?={@(?:link|linkcode|linkplain|tutorial))'

@@ -1504,25 +1516,27 @@ contexts:

15041516 - include: this-literal

15051517 - include: super-literal

15061518 method-declaration:

1507− - match: '(?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?\s*\b(constructor)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

1519+ - match: '(?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?\s*\b(constructor)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

15081520 captures:

15091521 1: storage.modifier.ts

15101522 2: storage.modifier.ts

1511− 3: storage.modifier.async.ts

1512− 4: storage.type.ts

1523+ 3: storage.modifier.ts

1524+ 4: storage.modifier.async.ts

1525+ 5: storage.type.ts

15131526 push:

15141527 - meta_scope: meta.method.declaration.ts

15151528 - match: '(?=\}|;|,|$)|(?<=\})'

15161529 pop: true

15171530 - include: method-declaration-name

15181531 - include: function-body

1519− - 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*))?[\(])'

1532+ - 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*))?[\(])'

15201533 captures:

15211534 1: storage.modifier.ts

15221535 2: storage.modifier.ts

1523− 3: storage.modifier.async.ts

1524− 4: keyword.operator.new.ts

1525− 5: keyword.generator.asterisk.ts

1536+ 3: storage.modifier.ts

1537+ 4: storage.modifier.async.ts

1538+ 5: keyword.operator.new.ts

1539+ 6: keyword.generator.asterisk.ts

15261540 push:

15271541 - meta_scope: meta.method.declaration.ts

15281542 - match: '(?=\}|;|,|$)|(?<=\})'

@@ -1530,7 +1544,7 @@ contexts:

15301544 - include: method-declaration-name

15311545 - include: function-body

15321546 - match: |-

1533− (?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(?!\$))|((?<!\$)(?:

1547+ (?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(?!\$))|((?<!\$)(?:

15341548 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3

15351549 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3

15361550 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3

@@ -1539,13 +1553,14 @@ contexts:

15391553 (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

15401554 (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

15411555 (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

1542− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])

1556+ )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])

15431557 captures:

15441558 1: storage.modifier.ts

15451559 2: storage.modifier.ts

1546− 3: storage.modifier.async.ts

1547− 4: storage.type.property.ts

1548− 5: keyword.generator.asterisk.ts

1560+ 3: storage.modifier.ts

1561+ 4: storage.modifier.async.ts

1562+ 5: storage.type.property.ts

1563+ 6: keyword.generator.asterisk.ts

15491564 push:

15501565 - meta_scope: meta.method.declaration.ts

15511566 - match: '(?=\}|;|,|$)|(?<=\})'

@@ -1582,7 +1597,7 @@ contexts:

15821597 3: storage.type.namespace.ts

15831598 push:

15841599 - meta_scope: meta.namespace.declaration.ts

1585− - match: '(?<=\})|(?=;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

1600+ - match: '(?<=\})|(?=;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

15861601 pop: true

15871602 - include: comment

15881603 - include: string

@@ -1598,9 +1613,7 @@ contexts:

15981613 - meta_scope: new.expr.ts

15991614 - match: '(?<=\))|(?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(]))))'

16001615 pop: true

1601− - include: paren-expression

1602− - include: class-declaration

1603− - include: type

1616+ - include: expression

16041617 null-literal:

16051618 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))null(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

16061619 scope: constant.language.null.ts

@@ -1781,7 +1794,7 @@ contexts:

17811794 (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

17821795 (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

17831796 (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

1784− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])

1797+ )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])

17851798 captures:

17861799 1: storage.modifier.async.ts

17871800 2: storage.type.property.ts

@@ -1802,7 +1815,7 @@ contexts:

18021815 (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

18031816 (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

18041817 (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

1805− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])

1818+ )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])

18061819 captures:

18071820 1: storage.modifier.async.ts

18081821 2: storage.type.property.ts

@@ -1864,10 +1877,10 @@ contexts:

18641877 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

18651878 )) |

18661879 ((async\s*)?(

1867− ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

1880+ ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

18681881 # sure shot arrow functions even if => is on new line

18691882 (

1870− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

1883+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

18711884 [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

18721885 (

18731886 ([)]\s*:) | # ():

@@ -1877,9 +1890,9 @@ contexts:

18771890

18781891 # arrow function possible to detect only with => on same line

18791892 (

1880− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

1881− $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($[^\($]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

1882− (\s*:\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

1893+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

1894+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

1895+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

18831896 \s*=> # arrow operator

18841897 )

18851898 ))

@@ -1930,7 +1943,7 @@ contexts:

19301943 - meta_scope: meta.object.member.ts

19311944 - match: '(?=,|\})'

19321945 pop: true

1933− - match: '(?<=:)\s*(async)?(?=\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)$\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'

1946+ - match: '(?<=:)\s*(async)?(?=\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)$\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'

19341947 captures:

19351948 1: storage.modifier.async.ts

19361949 push:

@@ -1946,7 +1959,7 @@ contexts:

19461959 0: meta.brace.round.ts

19471960 pop: true

19481961 - include: expression-inside-possibly-arrow-parens

1949− - match: '(?<=:)\s*(async)?\s*($)(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'

1962+ - match: '(?<=:)\s*(async)?\s*($)(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'

19501963 captures:

19511964 1: storage.modifier.async.ts

19521965 2: meta.brace.round.ts

@@ -1963,7 +1976,7 @@ contexts:

19631976 - match: (?<=\>)

19641977 pop: true

19651978 - include: type-parameters

1966− - match: '(?<=\>)\s*($)(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'

1979+ - match: '(?<=\>)\s*($)(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'

19671980 captures:

19681981 1: meta.brace.round.ts

19691982 push:

@@ -1997,11 +2010,11 @@ contexts:

19972010 - include: destructuring-parameter-rest

19982011 - include: variable-initializer

19992012 parameter-name:

20012014 captures:

20022015 1: storage.modifier.ts

20032016 - match: |-

20052018 # function assignment |

20062019 (=\s*(

20072020 ((async\s+)?(

@@ -2010,10 +2023,10 @@ contexts:

20102023 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

20112024 )) |

20122025 ((async\s*)?(

2013− ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

2026+ ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

20142027 # sure shot arrow functions even if => is on new line

20152028 (

2016− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

2029+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

20172030 [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

20182031 (

20192032 ([)]\s*:) | # ():

@@ -2023,9 +2036,9 @@ contexts:

20232036

20242037 # arrow function possible to detect only with => on same line

20252038 (

2026− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

2027− $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($[^\($]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

2028− (\s*:\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

2039+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

2040+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

2041+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

20292042 \s*=> # arrow operator

20302043 )

20312044 ))

@@ -2043,18 +2056,18 @@ contexts:

20432056 ))

20442057 )) |

20452058 (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |

2046− (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

2047− (:\s*(=>|($([^\($]|($[^\($]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

2059+ (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

2060+ (:\s*(=>|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

20482061 ((async\s+)?(

20492062 (function\s*[(<*]) |

20502063 (function\s+) |

20512064 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

20522065 )) |

20532066 ((async\s*)?(

2054− ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

2067+ ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

20552068 # sure shot arrow functions even if => is on new line

20562069 (

2057− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

2070+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

20582071 [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

20592072 (

20602073 ([)]\s*:) | # ():

@@ -2064,9 +2077,9 @@ contexts:

20642077

20652078 # arrow function possible to detect only with => on same line

20662079 (

2067− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

2068− $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($[^\($]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

2069− (\s*:\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

2080+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

2081+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

2082+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

20702083 \s*=> # arrow operator

20712084 )

20722085 ))

@@ -2077,7 +2090,7 @@ contexts:

20772090 3: entity.name.function.ts variable.language.this.ts

20782091 4: entity.name.function.ts

20792092 5: keyword.operator.optional.ts

20812094 captures:

20822095 1: storage.modifier.ts

20832096 2: keyword.operator.rest.ts

@@ -2137,14 +2150,14 @@ contexts:

21372150 pop: true

21382151 - include: expression

21392152 paren-expression-possibly-arrow:

2140− - match: '(?<=[(=,])\s*(async)?(?=\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?$\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'

2153+ - match: '(?<=[(=,])\s*(async)?(?=\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?$\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'

21412154 captures:

21422155 1: storage.modifier.async.ts

21432156 push:

21442157 - match: (?<=\))

21452158 pop: true

21462159 - include: paren-expression-possibly-arrow-with-typeparameters

2147− - match: '(?<=[(=,]|=>|^return|[^\._$[:alnum:]]return)\s*(async)?(?=\s*((((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\()|(<))\s*$)'

2160+ - match: '(?<=[(=,]|=>|^return|[^\._$[:alnum:]]return)\s*(async)?(?=\s*((((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\()|(<))\s*$)'

21482161 captures:

21492162 1: storage.modifier.async.ts

21502163 push:

@@ -2164,7 +2177,7 @@ contexts:

21642177 pop: true

21652178 - include: expression-inside-possibly-arrow-parens

21662179 possibly-arrow-return-type:

2167− - match: '(?<=\)|^)\s*(:)(?=\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*=>)'

2180+ - match: '(?<=\)|^)\s*(:)(?=\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*=>)'

21682181 captures:

21692182 1: meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts

21702183 push:

@@ -2211,23 +2224,23 @@ contexts:

22112224 pop: true

22122225 - include: string-character-escape

22132226 regex:

2214− - match: '(?<!\+\+|--|})(?<=[=(:,\[?+!]|^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[$)]|\\.|\[([^\]\\]|\\.)+\]|\(([^$\\]|\\.)+\))+\/([gimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'

2227+ - match: '(?<!\+\+|--|})(?<=[=(:,\[?+!]|^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[$)]|\\.|\[([^\]\\]|\\.)+\]|\(([^$\\]|\\.)+\))+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'

22152228 captures:

22162229 1: punctuation.definition.string.begin.ts

22172230 push:

22182231 - meta_scope: string.regexp.ts

2219− - match: "(/)([gimsuy]*)"

2232+ - match: "(/)([dgimsuy]*)"

22202233 captures:

22212234 1: punctuation.definition.string.end.ts

22222235 2: keyword.other.ts

22232236 pop: true

22242237 - include: regexp

2225− - match: '((?<![_$[:alnum:])\]]|\+\+|--|}|\*\/)|((?<=^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case))\s*)\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/([gimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'

2238+ - match: '((?<![_$[:alnum:])\]]|\+\+|--|}|\*\/)|((?<=^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case))\s*)\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'

22262239 captures:

22272240 0: punctuation.definition.string.begin.ts

22282241 push:

22292242 - meta_scope: string.regexp.ts

2230− - match: "(/)([gimsuy]*)"

2243+ - match: "(/)([dgimsuy]*)"

22312244 captures:

22322245 1: punctuation.definition.string.end.ts

22332246 2: keyword.other.ts

@@ -2430,7 +2443,7 @@ contexts:

24302443 4: support.variable.property.target.ts

24312444 - match: |-

24322445 (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?:

2433− (?:(constructor|length|prototype|__proto__)\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\())

2446+ (?:(constructor|length|prototype|__proto__)\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\())

24342447 |

24362449 captures:

@@ -2536,7 +2549,7 @@ contexts:

2539− |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\()

2552+ |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\()

25402553 captures:

25412554 1: punctuation.accessor.ts

25422555 2: punctuation.accessor.optional.ts

@@ -2703,20 +2716,34 @@ contexts:

27032716 0: case-clause.expr.ts punctuation.definition.section.case-statement.ts

27042717 - include: statements

27052718 template:

2706− - 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*)?`)'

2719+ - include: template-call

2720+ - match: "([_$[:alpha:]][_$[:alnum:]]*)?(`)"

2721+ captures:

2722+ 1: entity.name.function.tagged-template.ts

2723+ 2: punctuation.definition.string.template.begin.ts

2724+ push:

2725+ - meta_scope: string.template.ts

2726+ - match: "`"

2727+ captures:

2728+ 0: punctuation.definition.string.template.end.ts

2729+ pop: true

2730+ - include: template-substitution-element

2731+ - include: string-character-escape

2732+ template-call:

2733+ - 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*)?`)'

27072734 push:

27082735 - meta_scope: string.template.ts

27092736 - match: (?=`)

27102737 pop: true

27112738 - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*))'

27122739 push:

2713− - 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*)?`)'

2740+ - 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*)?`)'

27142741 pop: true

27152742 - include: support-function-call-identifiers

27162743 - match: "([_$[:alpha:]][_$[:alnum:]]*)"

27172744 scope: entity.name.function.tagged-template.ts

27182745 - include: type-arguments

2719− - 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*)`)'

2746+ - 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*)`)'

27202747 captures:

27212748 1: entity.name.function.tagged-template.ts

27222749 push:

@@ -2724,6 +2751,20 @@ contexts:

27242751 - match: (?=`)

27252752 pop: true

27262753 - include: type-arguments

2754+ template-substitution-element:

2755+ - match: '\$\{'

2756+ captures:

2757+ 0: punctuation.definition.template-expression.begin.ts

2758+ push:

2759+ - meta_scope: meta.template.expression.ts

2760+ - meta_content_scope: meta.embedded.line.ts

2761+ - match: '\}'

2762+ captures:

2763+ 0: punctuation.definition.template-expression.end.ts

2764+ pop: true

2765+ - include: expression

2766+ template-type:

2767+ - include: template-call

27272768 - match: "([_$[:alpha:]][_$[:alnum:]]*)?(`)"

27282769 captures:

27292770 1: entity.name.function.tagged-template.ts

@@ -2734,9 +2775,9 @@ contexts:

27342775 captures:

27352776 0: punctuation.definition.string.template.end.ts

27362777 pop: true

2737− - include: template-substitution-element

2778+ - include: template-type-substitution-element

27382779 - include: string-character-escape

2739− template-substitution-element:

2780+ template-type-substitution-element:

27402781 - match: '\$\{'

27412782 captures:

27422783 0: punctuation.definition.template-expression.begin.ts

@@ -2747,7 +2788,7 @@ contexts:

27472788 captures:

27482789 0: punctuation.definition.template-expression.end.ts

27492790 pop: true

2750− - include: expression

2791+ - include: type

27512792 ternary-expression:

27522793 - match: '(?!\?\.\s*[^[:digit:]])(\?)(?!\?)'

27532794 captures:

@@ -2763,7 +2804,7 @@ contexts:

27632804 scope: variable.language.this.ts

27642805 type:

27652806 - include: comment

2766− - include: string

2807+ - include: type-string

27672808 - include: numeric-literal

27682809 - include: type-primitive

27692810 - include: type-builtin-literals

@@ -2788,15 +2829,23 @@ contexts:

27882829 4: entity.name.type.alias.ts

27892830 push:

27902831 - meta_scope: meta.type.declaration.ts

2791− - match: '(?=\}|;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

2832+ - match: '(?=\}|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

27922833 pop: true

27932834 - include: comment

27942835 - include: type-parameters

2836+ - match: '(=)\s*(intrinsic)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

2837+ captures:

2838+ 1: keyword.operator.assignment.ts

2839+ 2: keyword.control.intrinsic.ts

2840+ push:

2841+ - match: '(?=\}|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

2842+ pop: true

2843+ - include: type

27952844 - match: (=)\s*

27962845 captures:

27972846 1: keyword.operator.assignment.ts

27982847 push:

2799− - match: '(?=\}|;|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

2848+ - match: '(?=\}|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

28002849 pop: true

28012850 - include: type

28022851 type-annotation:

@@ -2854,17 +2903,19 @@ contexts:

28542903 - include: type

28552904 - include: type

28562905 type-fn-type-parameters:

2857− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\b(?=\s*\<)'

2906+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(new)\b(?=\s*\<)'

28582907 captures:

2859− 1: meta.type.constructor.ts keyword.control.new.ts

2908+ 1: meta.type.constructor.ts storage.modifier.ts

2909+ 2: meta.type.constructor.ts keyword.control.new.ts

28602910 push:

28612911 - match: (?<=>)

28622912 pop: true

28632913 - include: comment

28642914 - include: type-parameters

2865− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\b\s*(?=\()'

2915+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(new)\b\s*(?=\()'

28662916 captures:

2867− 1: keyword.control.new.ts

2917+ 1: storage.modifier.ts

2918+ 2: keyword.control.new.ts

28682919 push:

28692920 - meta_scope: meta.type.constructor.ts

28702921 - match: (?<=\))

@@ -2993,8 +3044,6 @@ contexts:

29933044 scope: keyword.operator.ternary.ts

29943045 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))infer(?=\s+[_$[:alpha:]])'

29953046 scope: keyword.operator.expression.infer.ts

2996− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))awaited(?=\s+[_$[:alpha:]])'

2997− scope: keyword.operator.expression.awaited.ts

29983047 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*\()'

29993048 scope: keyword.operator.expression.import.ts

30003049 type-parameters:

@@ -3037,7 +3086,7 @@ contexts:

30373086 ))

30383087 )) |

30393088 (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |

3040− (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))))

3089+ (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))))

30413090 captures:

30423091 1: storage.modifier.ts

30433092 2: keyword.operator.rest.ts

@@ -3074,6 +3123,10 @@ contexts:

30743123 type-primitive:

30763125 scope: support.type.primitive.ts

3126+ type-string:

3127+ - include: qstring-single

3128+ - include: qstring-double

3129+ - include: template-type

30773130 type-tuple:

30783131 - match: '\['

30793132 captures:

@@ -3095,7 +3148,12 @@ contexts:

30953148 - include: punctuation-comma

30963149 typeof-operator:

30973150 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))typeof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

3098− scope: keyword.operator.expression.typeof.ts

3151+ captures:

3152+ 0: keyword.operator.expression.typeof.ts

3153+ push:

3154+ - match: '(?=[,);}\]=>:&|{\?]|$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

3155+ pop: true

3156+ - include: expression

30993157 undefined-literal:

31003158 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))undefined(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

31013159 scope: constant.language.undefined.ts

@@ -3103,7 +3161,7 @@ contexts:

31033161 - match: '(?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))'

31043162 push:

31053163 - meta_scope: meta.var.expr.ts

3106− - 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*$)))'

3164+ - 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*$)))'

31073165 pop: true

31083166 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*'

31093167 captures:

@@ -3136,7 +3194,7 @@ contexts:

31363194 3: storage.type.ts

31373195 push:

31383196 - meta_scope: meta.var.expr.ts

3139− - 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*$)))'

3197+ - 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*$)))'

31403198 pop: true

31413199 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*'

31423200 captures:

@@ -3173,10 +3231,10 @@ contexts:

31733231 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

31743232 )) |

31753233 ((async\s*)?(

3176− ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

3234+ ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

31773235 # sure shot arrow functions even if => is on new line

31783236 (

3179− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

3237+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

31803238 [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

31813239 (

31823240 ([)]\s*:) | # ():

@@ -3186,9 +3244,9 @@ contexts:

31863244

31873245 # arrow function possible to detect only with => on same line

31883246 (

3189− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

3190− $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($[^\($]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

3191− (\s*:\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

3247+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

3248+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

3249+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

31923250 \s*=> # arrow operator

31933251 )

31943252 ))

@@ -3206,18 +3264,18 @@ contexts:

32063264 ))

32073265 )) |

32083266 (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |

3209− (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

3210− (:\s*(=>|($([^\($]|($[^\($]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

3267+ (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

3268+ (:\s*(=>|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

32113269 ((async\s+)?(

32123270 (function\s*[(<*]) |

32133271 (function\s+) |

32143272 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

32153273 )) |

32163274 ((async\s*)?(

3217− ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

3275+ ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

32183276 # sure shot arrow functions even if => is on new line

32193277 (

3220− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

3278+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

32213279 [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

32223280 (

32233281 ([)]\s*:) | # ():

@@ -3227,9 +3285,9 @@ contexts:

32273285

32283286 # arrow function possible to detect only with => on same line

32293287 (

3230− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

3231− $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($[^\($]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

3232− (\s*:\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

3288+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

3289+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

3290+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

32333291 \s*=> # arrow operator

32343292 )

32353293 ))

@@ -3260,10 +3318,10 @@ contexts:

32603318 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

32613319 )) |

32623320 ((async\s*)?(

3263− ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

3321+ ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

32643322 # sure shot arrow functions even if => is on new line

32653323 (

3266− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

3324+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

32673325 [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

32683326 (

32693327 ([)]\s*:) | # ():

@@ -3273,9 +3331,9 @@ contexts:

32733331

32743332 # arrow function possible to detect only with => on same line

32753333 (

3276− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

3277− $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($[^\($]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

3278− (\s*:\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

3334+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

3335+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

3336+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

32793337 \s*=> # arrow operator

32803338 )

32813339 ))

@@ -3293,18 +3351,18 @@ contexts:

32933351 ))

32943352 )) |

32953353 (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |

3296− (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

3297− (:\s*(=>|($([^\($]|($[^\($]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

3354+ (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

3355+ (:\s*(=>|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

32983356 ((async\s+)?(

32993357 (function\s*[(<*]) |

33003358 (function\s+) |

33013359 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

33023360 )) |

33033361 ((async\s*)?(

3304− ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{[^\{\}]*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[[^\[\]]*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

3362+ ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

33053363 # sure shot arrow functions even if => is on new line

33063364 (

3307− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

3365+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

33083366 [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

33093367 (

33103368 ([)]\s*:) | # ():

@@ -3314,9 +3372,9 @@ contexts:

33143372

33153373 # arrow function possible to detect only with => on same line

33163374 (

3317− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

3318− $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($[^\($]*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

3319− (\s*:\s*([^<>\{\}]|\<([^<>]|\<[^<>]+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

3375+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

3376+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

3377+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

33203378 \s*=> # arrow operator

33213379 )

33223380 ))

assets/syntaxes/02_Extra/TypsecriptReact.sublime-syntax+896−477

@@ -9,10 +9,7 @@ contexts:

99 main:

1010 - include: directives

1111 - include: statements

12− - match: \A(#!).*(?=$)

13− scope: comment.line.shebang.ts

14− captures:

15− 1: punctuation.definition.comment.ts

12+ - include: shebang

1613 comment:

1714 - match: /\*\*(?!/)

1815 captures:

@@ -44,10 +41,10 @@ contexts:

4441 5: punctuation.decorator.internaldeclaration.tsx

4542 push:

4643 - meta_content_scope: comment.line.double-slash.tsx

47− - match: (?=^)

44+ - match: (?=$)

4845 pop: true

4946 access-modifier:

5148 scope: storage.modifier.tsx

5249 after-operator-block-as-object-literal:

5350 - match: '(?<!\+\+|--)(?<=[:=(,\[?+!>]|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^yield|[^\._$[:alnum:]]yield|^throw|[^\._$[:alnum:]]throw|^in|[^\._$[:alnum:]]in|^of|[^\._$[:alnum:]]of|^typeof|[^\._$[:alnum:]]typeof|&&|\|\||\*)\s*(\{)'

@@ -109,8 +106,8 @@ contexts:

109106 (?=

110107 # sure shot arrow functions even if => is on new line

111108 (

112− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

113− [(]\s*

110+ [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

114111 (

115112 ([)]\s*:) | # ():

116113 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

@@ -121,9 +118,9 @@ contexts:

121118 ) |

122119 # arrow function possible to detect only with => on same line

123120 (

124− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

125− $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

126− (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

121+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

122+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

123+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

127124 \s*=> # arrow operator

128125 )

129126 )

@@ -138,13 +135,15 @@ contexts:

138135 - include: type-parameters

139136 - include: function-parameters

140137 - include: arrow-return-type

138+ - include: possibly-arrow-return-type

141139 - match: "=>"

142140 captures:

143141 0: storage.type.function.arrow.tsx

144142 push:

145143 - meta_scope: meta.arrow.tsx

146− - match: '(?<=\}|\S)(?<!=>)|((?!\{)(?=\S))'

144+ - match: '((?<=\}|\S)(?<!=>)|((?!\{)(?=\S)))(?!\/[\/\*])'

147145 pop: true

146+ - include: single-line-comment-consuming-line-ending

148147 - include: decl-block

149148 - include: expression

150149 arrow-return-type:

@@ -170,6 +169,8 @@ contexts:

170169 binding-element:

171170 - include: comment

172171 - include: string

172+ - include: numeric-literal

173+ - include: regex

173174 - include: object-binding-pattern

174175 - include: array-binding-pattern

175176 - include: destructuring-variable-rest

@@ -177,6 +178,8 @@ contexts:

177178 binding-element-const:

178179 - include: comment

179180 - include: string

181+ - include: numeric-literal

182+ - include: regex

180183 - include: object-binding-pattern-const

181184 - include: array-binding-pattern-const

182185 - include: destructuring-variable-rest-const

@@ -200,11 +203,12 @@ contexts:

200203 cast:

201204 - include: jsx

202205 class-declaration:

203− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(export)\s+)?\b(?:(abstract)\s+)?\b(class)\b(?=\s+|/[/*])'

206+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(?:(abstract)\s+)?\b(class)\b(?=\s+|/[/*])'

204207 captures:

205208 1: keyword.control.export.tsx

206209 2: storage.modifier.tsx

207− 3: storage.type.class.tsx

210+ 3: storage.modifier.tsx

211+ 4: storage.type.class.tsx

208212 push:

209213 - meta_scope: meta.class.tsx

210214 - match: '(?<=\})'

@@ -219,9 +223,10 @@ contexts:

219223 - include: type-parameters

220224 - include: class-or-interface-body

221225 class-expression:

222− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(class)\b(?=\s+|[<{]|\/[\/*])'

226+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(class)\b(?=\s+|[<{]|\/[\/*])'

223227 captures:

224− 1: storage.type.class.tsx

228+ 1: storage.modifier.tsx

229+ 2: storage.type.class.tsx

225230 push:

226231 - meta_scope: meta.class.tsx

227232 - match: '(?<=\})'

@@ -238,6 +243,11 @@ contexts:

238243 pop: true

239244 - include: comment

240245 - include: decorator

246+ - match: (?<=:)\s*

247+ push:

248+ - match: '(?=\s|[;),}\]:\-\+]|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

249+ pop: true

250+ - include: expression

241251 - include: method-declaration

242252 - include: indexer-declaration

243253 - include: field-declaration

@@ -284,9 +294,15 @@ contexts:

285295 scope: keyword.control.loop.tsx

286296 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(return)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

287− scope: keyword.control.flow.tsx

297+ captures:

298+ 0: keyword.control.flow.tsx

299+ push:

300+ - match: '(?=[;}]|$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

301+ pop: true

302+ - include: expression

288303 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default|switch)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

289304 scope: keyword.control.switch.tsx

305+ - include: if-statement

290306 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(else|if)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

291307 scope: keyword.control.conditional.tsx

292308 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(with)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

@@ -295,8 +311,6 @@ contexts:

295311 scope: keyword.control.tsx

296312 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(debugger)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

297313 scope: keyword.other.debugger.tsx

298− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(declare)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

299− scope: storage.modifier.tsx

300314 decl-block:

301315 - match: '\{'

302316 captures:

@@ -320,6 +334,8 @@ contexts:

320334 - include: import-equals-declaration

321335 - include: import-declaration

322336 - include: export-declaration

337+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(declare|export)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

338+ scope: storage.modifier.tsx

323339 decorator:

324340 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))\@'

325341 captures:

@@ -333,7 +349,7 @@ contexts:

333349 - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\{)'

334350 push:

335351 - meta_scope: meta.object-binding-pattern-variable.tsx

336− - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

352+ - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'

337353 pop: true

338354 - include: object-binding-pattern-const

339355 - include: type-annotation

@@ -341,15 +357,16 @@ contexts:

341357 - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\[)'

342358 push:

343359 - meta_scope: meta.array-binding-pattern-variable.tsx

344− - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

360+ - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'

345361 pop: true

346362 - include: array-binding-pattern-const

347363 - include: type-annotation

348364 - include: comment

349365 destructuring-parameter:

350− - match: '(?<!=|:)\s*(\{)'

366+ - match: '(?<!=|:)\s*(?:(\.\.\.)\s*)?(\{)'

351367 captures:

352− 1: punctuation.definition.binding-pattern.object.tsx

368+ 1: keyword.operator.rest.tsx

369+ 2: punctuation.definition.binding-pattern.object.tsx

353370 push:

354371 - meta_scope: meta.parameter.object-binding-pattern.tsx

355372 - match: '\}'

@@ -357,9 +374,10 @@ contexts:

357374 0: punctuation.definition.binding-pattern.object.tsx

358375 pop: true

359376 - include: parameter-object-binding-element

360− - match: '(?<!=|:)\s*(\[)'

377+ - match: '(?<!=|:)\s*(?:(\.\.\.)\s*)?(\[)'

361378 captures:

362− 1: punctuation.definition.binding-pattern.array.tsx

379+ 1: keyword.operator.rest.tsx

380+ 2: punctuation.definition.binding-pattern.array.tsx

363381 push:

364382 - meta_scope: meta.paramter.array-binding-pattern.tsx

365383 - match: '\]'

@@ -377,7 +395,7 @@ contexts:

377395 - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\{)'

378396 push:

379397 - meta_scope: meta.object-binding-pattern-variable.tsx

380− - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

398+ - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'

381399 pop: true

382400 - include: object-binding-pattern

383401 - include: type-annotation

@@ -385,7 +403,7 @@ contexts:

385403 - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\[)'

386404 push:

387405 - meta_scope: meta.array-binding-pattern-variable.tsx

388− - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

406+ - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'

389407 pop: true

390408 - include: array-binding-pattern

391409 - include: type-annotation

@@ -401,12 +419,12 @@ contexts:

401419 1: keyword.operator.rest.tsx

402420 2: meta.definition.variable.tsx variable.other.constant.tsx

403421 directives:

404− - match: '^(///)\s*(?=<(reference|amd-dependency|amd-module)(\s+(path|types|no-default-lib|lib|name)\s*=\s*((\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")))+\s*/>\s*$)'

422+ - match: '^(///)\s*(?=<(reference|amd-dependency|amd-module)(\s+(path|types|no-default-lib|lib|name)\s*=\s*((\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)))+\s*/>\s*$)'

405423 captures:

406424 1: punctuation.definition.comment.tsx

407425 push:

408426 - meta_scope: comment.line.triple-slash.directive.tsx

409− - match: (?=^)

427+ - match: (?=$)

410428 pop: true

411429 - match: (<)(reference|amd-dependency|amd-module)

412430 captures:

@@ -668,13 +686,18 @@ contexts:

668686 captures:

669687 1: punctuation.definition.block.tag.jsdoc

670688 - include: inline-tags

689+ - match: '((@)(?:[_$[:alpha:]][_$[:alnum:]]*))(?=\s+)'

690+ captures:

691+ 1: storage.type.class.jsdoc

692+ 2: punctuation.definition.block.tag.jsdoc

671693 enum-declaration:

672− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:\b(const)\s+)?\b(enum)\s+([_$[:alpha:]][_$[:alnum:]]*)'

694+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?(?:\b(const)\s+)?\b(enum)\s+([_$[:alpha:]][_$[:alnum:]]*)'

673695 captures:

674696 1: keyword.control.export.tsx

675697 2: storage.modifier.tsx

676− 3: storage.type.enum.tsx

677− 4: entity.name.type.enum.tsx

698+ 3: storage.modifier.tsx

699+ 4: storage.type.enum.tsx

700+ 5: entity.name.type.enum.tsx

678701 push:

679702 - meta_scope: meta.enum.declaration.tsx

680703 - match: '(?<=\})'

@@ -697,7 +720,7 @@ contexts:

697720 pop: true

698721 - include: comment

699722 - include: variable-initializer

700− - match: '(?=((\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\])))'

723+ - match: '(?=((\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\])))'

701724 push:

702725 - match: '(?=,|\}|$)'

703726 pop: true

@@ -713,22 +736,25 @@ contexts:

713736 2: keyword.control.as.tsx

714737 3: storage.type.namespace.tsx

715738 4: entity.name.type.module.tsx

716− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:(?:\s*(=))|(?:\s+(default)(?=\s+)))'

739+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:\s+(type))?(?:(?:\s*(=))|(?:\s+(default)(?=\s+)))'

717740 captures:

718741 1: keyword.control.export.tsx

719− 2: keyword.operator.assignment.tsx

720− 3: keyword.control.default.tsx

742+ 2: keyword.control.type.tsx

743+ 3: keyword.operator.assignment.tsx

744+ 4: keyword.control.default.tsx

721745 push:

722746 - meta_scope: meta.export.default.tsx

724748 pop: true

749+ - include: interface-declaration

725750 - include: expression

726− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?!\s*:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

751+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:\s+(type))?\b(?!(\$)|(\s*:))((?=\s*[\{*])|((?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s|,))(?!\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b)))'

727752 captures:

728− 0: keyword.control.export.tsx

753+ 1: keyword.control.export.tsx

754+ 2: keyword.control.type.tsx

729755 push:

730756 - meta_scope: meta.export.tsx

732758 pop: true

733759 - include: import-export-declaration

734760 expression:

@@ -737,7 +763,105 @@ contexts:

737763 - include: expressionPunctuations

738764 expression-inside-possibly-arrow-parens:

739765 - include: expressionWithoutIdentifiers

740− - include: function-parameters-body

766+ - include: comment

767+ - include: string

768+ - include: decorator

769+ - include: destructuring-parameter

771+ captures:

772+ 1: storage.modifier.tsx

773+ - match: |-

775+ # function assignment |

776+ (=\s*(

777+ ((async\s+)?(

778+ (function\s*[(<*]) |

779+ (function\s+) |

780+ ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

781+ )) |

782+ ((async\s*)?(

783+ ((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

784+ # sure shot arrow functions even if => is on new line

785+ (

786+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

787+ [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

788+ (

789+ ([)]\s*:) | # ():

790+ ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

791+ )

792+ ) |

793+ (

794+ [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

795+ ) |

796+ # arrow function possible to detect only with => on same line

797+ (

798+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

799+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

800+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

801+ \s*=> # arrow operator

802+ )

803+ ))

804+ )) |

806+ (:\s*(

807+ (<) |

808+ ([(]\s*(

809+ ([)]) |

810+ (\.\.\.) |

811+ ([_$[:alnum:]]+\s*(

812+ ([:,?=])|

813+ ([)]\s*=>)

814+ ))

815+ ))

816+ )) |

817+ (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |

818+ (:\s*((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

819+ (:\s*(=>|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

820+ ((async\s+)?(

821+ (function\s*[(<*]) |

822+ (function\s+) |

823+ ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

824+ )) |

825+ ((async\s*)?(

826+ ((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

827+ # sure shot arrow functions even if => is on new line

828+ (

829+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

830+ [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

831+ (

832+ ([)]\s*:) | # ():

833+ ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

834+ )

835+ ) |

836+ (

837+ [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

838+ ) |

839+ # arrow function possible to detect only with => on same line

840+ (

841+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

842+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

843+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

844+ \s*=> # arrow operator

845+ )

846+ ))

847+ )))

848+ captures:

849+ 1: storage.modifier.tsx

850+ 2: keyword.operator.rest.tsx

851+ 3: entity.name.function.tsx variable.language.this.tsx

852+ 4: entity.name.function.tsx

853+ 5: keyword.operator.optional.tsx

855+ captures:

856+ 1: storage.modifier.tsx

857+ 2: keyword.operator.rest.tsx

858+ 3: variable.parameter.tsx variable.language.this.tsx

859+ 4: variable.parameter.tsx

860+ 5: keyword.operator.optional.tsx

861+ - include: type-annotation

862+ - include: variable-initializer

863+ - match: ","

864+ scope: punctuation.separator.parameter.tsx

741865 - include: identifiers

742866 - include: expressionPunctuations

743867 expression-operators:

@@ -769,11 +893,15 @@ contexts:

769893 - include: typeof-operator

770894 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))void(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

771895 scope: keyword.operator.expression.void.tsx

896+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+(const)(?=\s*($|[;,:})\]]))'

897+ captures:

898+ 1: keyword.control.as.tsx

899+ 2: storage.modifier.tsx

772900 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+'

773901 captures:

774902 1: keyword.control.as.tsx

775903 push:

776− - match: '(?=$|^|[;,:})\]]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+))'

904+ - match: '(?=^|[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+)|(\s+\<))'

777905 pop: true

778906 - include: type

779907 - match: \.\.\.

@@ -788,7 +916,12 @@ contexts:

788916 scope: keyword.operator.comparison.tsx

789917 - match: <=|>=|<>|<|>

790918 scope: keyword.operator.relational.tsx

791− - match: \!|&&|\|\|

919+ - match: '(?<=[_$[:alnum:]])(\!)\s*(?:(/=)|(?:(/)(?![/*])))'

920+ captures:

921+ 1: keyword.operator.logical.tsx

922+ 2: keyword.operator.assignment.compound.tsx

923+ 3: keyword.operator.arithmetic.tsx

924+ - match: \!|&&|\|\||\?\?

792925 scope: keyword.operator.logical.tsx

793926 - match: \&|~|\^|\|

794927 scope: keyword.operator.bitwise.tsx

@@ -800,9 +933,18 @@ contexts:

800933 scope: keyword.operator.increment.tsx

801934 - match: '%|\*|/|-|\+'

802935 scope: keyword.operator.arithmetic.tsx

803− - match: '(?<=[_$[:alnum:])\]])\s*(/)(?![/*])'

936+ - match: '(?<=[_$[:alnum:])\]])\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)+(?:(/=)|(?:(/)(?![/*]))))'

937+ push:

938+ - match: '(?:(/=)|(?:(/)(?!\*([^\*]|(\*[^\/]))*\*\/)))'

939+ captures:

940+ 1: keyword.operator.assignment.compound.tsx

941+ 2: keyword.operator.arithmetic.tsx

942+ pop: true

943+ - include: comment

944+ - match: '(?<=[_$[:alnum:])\]])\s*(?:(/=)|(?:(/)(?![/*])))'

804945 captures:

805− 1: keyword.operator.arithmetic.tsx

946+ 1: keyword.operator.assignment.compound.tsx

947+ 2: keyword.operator.arithmetic.tsx

806948 expressionPunctuations:

807949 - include: punctuation-comma

808950 - include: punctuation-accessor

@@ -810,7 +952,6 @@ contexts:

810952 - include: jsx

811953 - include: string

812954 - include: regex

813− - include: template

814955 - include: comment

815956 - include: function-expression

816957 - include: class-expression

@@ -828,143 +969,123 @@ contexts:

828969 - include: paren-expression

829970 field-declaration:

830971 - match: |-

831− (?x)(?<!\()(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s+)?(?=\s*((\b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$))|(\b(?<!\$)0(b|B)[01][01_]*\b(?!\$))|(\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$))|((?<!\$)(?:

832− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

833− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

834− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

835− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

836− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

837− (?:\b[0-9][0-9_]*(\.)\B)| # 1.

838− (?:\B(\.)[0-9][0-9_]*\b)| # .1

839− (?:\b[0-9][0-9_]*\b(?!\.)) # 1

840− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))

972+ (?x)(?<!\()(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\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(?!\$))|((?<!\$)(?:

973+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3

974+ (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3

975+ (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3

976+ (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3

977+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1

978+ (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

979+ (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

980+ (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

981+ )(?!\$))|(\#?[_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(?:(?:(\?)|(\!))\s*)?(=|:|;|,|\}|$))

841982 captures:

842983 1: storage.modifier.tsx

843984 push:

844985 - meta_scope: meta.field.declaration.tsx

845986 - match: |-

846− (?x)(?=\}|;|,|$|(^(?!\s*((\b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$))|(\b(?<!\$)0(b|B)[01][01_]*\b(?!\$))|(\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$))|((?<!\$)(?:

847− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

848− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

849− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

850− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

851− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

852− (?:\b[0-9][0-9_]*(\.)\B)| # 1.

853− (?:\B(\.)[0-9][0-9_]*\b)| # .1

854− (?:\b[0-9][0-9_]*\b(?!\.)) # 1

855− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))))|(?<=\})

987+ (?x)(?=\}|;|,|$|(^(?!\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(?!\$))|((?<!\$)(?:

988+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3

989+ (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3

990+ (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3

991+ (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3

992+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1

993+ (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

994+ (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

995+ (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

996+ )(?!\$))|(\#?[_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(?:(?:(\?)|(\!))\s*)?(=|:|;|,|$))))|(?<=\})

856997 pop: true

857998 - include: variable-initializer

999+ - include: type-annotation

1000+ - include: string

1001+ - include: array-literal

1002+ - include: numeric-literal

1003+ - include: comment

8581004 - match: |-

859− (?x)(?=((\b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$))|(\b(?<!\$)0(b|B)[01][01_]*\b(?!\$))|(\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$))|((?<!\$)(?:

860− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

861− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

862− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

863− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

864− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

865− (?:\b[0-9][0-9_]*(\.)\B)| # 1.

866− (?:\B(\.)[0-9][0-9_]*\b)| # .1

867− (?:\b[0-9][0-9_]*\b(?!\.)) # 1

868− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))

869− push:

870− - match: |-

871− (?x)(?=[};,=]|$|(^(?!\s*((\b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$))|(\b(?<!\$)0(b|B)[01][01_]*\b(?!\$))|(\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$))|((?<!\$)(?:

872− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

873− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

874− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

875− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

876− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

877− (?:\b[0-9][0-9_]*(\.)\B)| # 1.

878− (?:\B(\.)[0-9][0-9_]*\b)| # .1

879− (?:\b[0-9][0-9_]*\b(?!\.)) # 1

880− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))))|(?<=\})

881− pop: true

882− - include: type-annotation

883− - include: string

884− - include: array-literal

885− - include: numeric-literal

886− - include: comment

887− - match: |-

888− (?x)([_$[:alpha:]][_$[:alnum:]]*)(\?)?(?=(\?\s*)?\s*

889− # function assignment |

890− (=\s*(

891− ((async\s+)?(

892− (function\s*[(<*]) |

893− (function\s+) |

894− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

895− )) |

896− ((async\s*)?(

897− ((<\s*$)|([\(]\s*([\{\[]\s*)?$)) |

898− # sure shot arrow functions even if => is on new line

899− (

900− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

901− [(]\s*

902− (

903− ([)]\s*:) | # ():

904− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

905− )

906− ) |

907− (

908− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

909− ) |

910− # arrow function possible to detect only with => on same line

911− (

912− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

913− $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

914− (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

915− \s*=> # arrow operator

916− )

917− ))

918− )) |

920− (:\s*(

921− (<) |

922− ([(]\s*(

923− ([)]) |

924− (\.\.\.) |

925− ([_$[:alnum:]]+\s*(

926− ([:,?=])|

927− ([)]\s*=>)

928− ))

929− ))

930− )) |

931− (:\s*((<\s*$)|([\(]\s*([\{\[]\s*)?$))) |

932− (:\s*(=>|($([^\($]|($[^\($]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

933− ((async\s+)?(

934− (function\s*[(<*]) |

935− (function\s+) |

936− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

937− )) |

938− ((async\s*)?(

939− ((<\s*$)|([\(]\s*([\{\[]\s*)?$)) |

940− # sure shot arrow functions even if => is on new line

941− (

942− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

943− [(]\s*

944− (

945− ([)]\s*:) | # ():

946− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

947− )

948− ) |

949− (

950− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

951− ) |

952− # arrow function possible to detect only with => on same line

953− (

954− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

955− $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

956− (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

957− \s*=> # arrow operator

958− )

959− ))

960− )))

961− captures:

962− 1: meta.definition.property.tsx entity.name.function.tsx

963− 2: keyword.operator.optional.tsx

964− - match: "[_$[:alpha:]][_$[:alnum:]]*"

965− scope: meta.definition.property.tsx variable.object.property.tsx

966− - match: \?

967− scope: keyword.operator.optional.tsx

1005+ (?x)(\#?[_$[:alpha:]][_$[:alnum:]]*)(?:(\?)|(\!))?(?=\s*\s*

1006+ # function assignment |

1007+ (=\s*(

1008+ ((async\s+)?(

1009+ (function\s*[(<*]) |

1010+ (function\s+) |

1011+ ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

1012+ )) |

1013+ ((async\s*)?(

1014+ ((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

1015+ # sure shot arrow functions even if => is on new line

1016+ (

1017+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

1018+ [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

1019+ (

1020+ ([)]\s*:) | # ():

1021+ ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

1022+ )

1023+ ) |

1024+ (

1025+ [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

1026+ ) |

1027+ # arrow function possible to detect only with => on same line

1028+ (

1029+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

1030+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

1031+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

1032+ \s*=> # arrow operator

1033+ )

1034+ ))

1035+ )) |

1037+ (:\s*(

1038+ (<) |

1039+ ([(]\s*(

1040+ ([)]) |

1041+ (\.\.\.) |

1042+ ([_$[:alnum:]]+\s*(

1043+ ([:,?=])|

1044+ ([)]\s*=>)

1045+ ))

1046+ ))

1047+ )) |

1048+ (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |

1049+ (:\s*((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

1050+ (:\s*(=>|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

1051+ ((async\s+)?(

1052+ (function\s*[(<*]) |

1053+ (function\s+) |

1054+ ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

1055+ )) |

1056+ ((async\s*)?(

1057+ ((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

1058+ # sure shot arrow functions even if => is on new line

1059+ (

1060+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

1061+ [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

1062+ (

1063+ ([)]\s*:) | # ():

1064+ ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

1065+ )

1066+ ) |

1067+ (

1068+ [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

1069+ ) |

1070+ # arrow function possible to detect only with => on same line

1071+ (

1072+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

1073+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

1074+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

1075+ \s*=> # arrow operator

1076+ )

1077+ ))

1078+ )))

1079+ captures:

1080+ 1: meta.definition.property.tsx entity.name.function.tsx

1081+ 2: keyword.operator.optional.tsx

1082+ 3: keyword.operator.definiteassignment.tsx

1083+ - match: '\#?[_$[:alpha:]][_$[:alnum:]]*'

1084+ scope: meta.definition.property.tsx variable.object.property.tsx

1085+ - match: \?

1086+ scope: keyword.operator.optional.tsx

1087+ - match: \!

1088+ scope: keyword.operator.definiteassignment.tsx

9681089 for-loop:

9691090 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))for(?=((\s+|(\s*\/\*([^\*]|(\*[^\/]))*\*\/\s*))await)?\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)?(\())'

9701091 captures:

@@ -991,43 +1112,59 @@ contexts:

9911112 - include: type-parameters

9921113 - include: function-parameters

9931114 - include: return-type

1115+ - include: type-function-return-type

9941116 - include: decl-block

9951117 - match: \*

9961118 scope: keyword.generator.asterisk.tsx

9971119 function-call:

998− - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)\s*(\?\.\s*)?(<\s*(((keyof|infer)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))(?=\s*([\<\>\,\.\[=]|&(?!&)|\|(?!\|)))))([^<>$]|(\(([^\($]|($[^\($]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))(?=\s*([\<\>\,\.\[=]|&(?!&)|\|(?!\|)))))([^<>$]|(\(([^\($]|($[^\($]*\)))*\))|(?<==)\>)*(?!=)\>)*(?!=)>\s*)?\()'

1120+ - 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*)?\())'

9991121 push:

1000− - match: '(?<=\))(?!(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)\s*(\?\.\s*)?(<\s*(((keyof|infer)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))(?=\s*([\<\>\,\.\[=]|&(?!&)|\|(?!\|)))))([^<>$]|(\(([^\($]|($[^\($]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))(?=\s*([\<\>\,\.\[=]|&(?!&)|\|(?!\|)))))([^<>$]|(\(([^\($]|($[^\($]*\)))*\))|(?<==)\>)*(?!=)\>)*(?!=)>\s*)?\()'

1122+ - 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*)?\())'

10011123 pop: true

1002− - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*))'

1124+ - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))'

10031125 push:

10041126 - meta_scope: meta.function-call.tsx

1005− - match: '(?=\s*(\?\.\s*)?(<\s*(((keyof|infer)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))(?=\s*([\<\>\,\.\[=]|&(?!&)|\|(?!\|)))))([^<>$]|(\(([^\($]|($[^\($]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))(?=\s*([\<\>\,\.\[=]|&(?!&)|\|(?!\|)))))([^<>$]|(\(([^\($]|($[^\($]*\)))*\))|(?<==)\>)*(?!=)\>)*(?!=)>\s*)?\()'

1127+ - 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*)?\())'

10061128 pop: true

1007− - include: literal

1008− - include: support-objects

1009− - include: object-identifiers

1010− - include: punctuation-accessor

1011− - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*[\(]\s*[\"\''\`]))'

1012− scope: keyword.operator.expression.import.tsx

1013− - match: "([_$[:alpha:]][_$[:alnum:]]*)"

1014− scope: entity.name.function.tsx

1129+ - include: function-call-target

10151130 - include: comment

1016− - match: \?\.

1017− scope: meta.function-call.tsx punctuation.accessor.optional.tsx

1131+ - include: function-call-optionals

10181132 - include: type-arguments

10191133 - include: paren-expression

1134+ - match: '(?=(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))(<\s*[\{\[\(]\s*$))'

1135+ push:

1136+ - match: '(?<=\>)(?!(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))(<\s*[\{\[\(]\s*$))'

1137+ pop: true

1138+ - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))'

1139+ push:

1140+ - meta_scope: meta.function-call.tsx

1141+ - match: '(?=(<\s*[\{\[\(]\s*$))'

1142+ pop: true

1143+ - include: function-call-target

1144+ - include: comment

1145+ - include: function-call-optionals

1146+ - include: type-arguments

1147+ function-call-optionals:

1148+ - match: \?\.

1149+ scope: meta.function-call.tsx punctuation.accessor.optional.tsx

1150+ - match: \!

1151+ scope: meta.function-call.tsx keyword.operator.definiteassignment.tsx

1152+ function-call-target:

1153+ - include: support-function-call-identifiers

1154+ - match: '(\#?[_$[:alpha:]][_$[:alnum:]]*)'

1155+ scope: entity.name.function.tsx

10201156 function-declaration:

1021− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(export)\s+)?(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'

1157+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'

10221158 captures:

10231159 1: keyword.control.export.tsx

1024− 2: storage.modifier.async.tsx

1025− 3: storage.type.function.tsx

1026− 4: keyword.generator.asterisk.tsx

1027− 5: meta.definition.function.tsx entity.name.function.tsx

1160+ 2: storage.modifier.tsx

1161+ 3: storage.modifier.async.tsx

1162+ 4: storage.type.function.tsx

1163+ 5: keyword.generator.asterisk.tsx

1164+ 6: meta.definition.function.tsx entity.name.function.tsx

10281165 push:

10291166 - meta_scope: meta.function.tsx

1030− - match: '(?=$|^|;)|(?<=\})'

1167+ - match: '(?=;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))|(?<=\})'

10311168 pop: true

10321169 - include: function-name

10331170 - include: function-body

@@ -1040,9 +1177,10 @@ contexts:

10401177 4: meta.definition.function.tsx entity.name.function.tsx

10411178 push:

10421179 - meta_scope: meta.function.expression.tsx

1043− - match: '(?<=\})'

1180+ - match: '(?=;)|(?<=\})'

10441181 pop: true

10451182 - include: function-name

1183+ - include: single-line-comment-consuming-line-ending

10461184 - include: function-body

10471185 function-name:

10481186 - match: "[_$[:alpha:]][_$[:alnum:]]*"

@@ -1060,10 +1198,11 @@ contexts:

10601198 - include: function-parameters-body

10611199 function-parameters-body:

10621200 - include: comment

1201+ - include: string

10631202 - include: decorator

10641203 - include: destructuring-parameter

10651204 - include: parameter-name

1066− - include: type-annotation

1205+ - include: parameter-type-annotation

10671206 - include: variable-initializer

10681207 - match: ","

10691208 scope: punctuation.separator.parameter.tsx

@@ -1077,11 +1216,11 @@ contexts:

10771216 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

10781217 )) |

10791218 ((async\s*)?(

1080− ((<\s*$)|([\(]\s*([\{\[]\s*)?$)) |

1219+ ((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

10811220 # sure shot arrow functions even if => is on new line

10821221 (

1083− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

1084− [(]\s*

1222+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

1223+ [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

10851224 (

10861225 ([)]\s*:) | # ():

10871226 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

@@ -1092,9 +1231,9 @@ contexts:

10921231 ) |

10931232 # arrow function possible to detect only with => on same line

10941233 (

1095− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

1096− $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

1097− (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

1234+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

1235+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

1236+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

10981237 \s*=> # arrow operator

10991238 )

11001239 ))

@@ -1103,12 +1242,12 @@ contexts:

11031242 1: punctuation.accessor.tsx

11041243 2: punctuation.accessor.optional.tsx

11051244 3: entity.name.function.tsx

1106− - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])'

1245+ - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(\#?[[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])'

11071246 captures:

11081247 1: punctuation.accessor.tsx

11091248 2: punctuation.accessor.optional.tsx

11101249 3: variable.other.constant.property.tsx

1111− - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*([_$[:alpha:]][_$[:alnum:]]*)'

1250+ - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(\#?[_$[:alpha:]][_$[:alnum:]]*)'

11121251 captures:

11131252 1: punctuation.accessor.tsx

11141253 2: punctuation.accessor.optional.tsx

@@ -1117,15 +1256,46 @@ contexts:

11171256 scope: variable.other.constant.tsx

11181257 - match: "[_$[:alpha:]][_$[:alnum:]]*"

11191258 scope: variable.other.readwrite.tsx

1259+ if-statement:

1260+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bif\s*($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))\s*(?!\{))'

1261+ push:

1262+ - match: '(?=;|$|\})'

1263+ pop: true

1264+ - include: comment

1265+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(if)\s*(\()'

1266+ captures:

1267+ 1: keyword.control.conditional.tsx

1268+ 2: meta.brace.round.tsx

1269+ push:

1270+ - match: \)

1271+ captures:

1272+ 0: meta.brace.round.tsx

1273+ pop: true

1274+ - include: expression

1275+ - match: '(?<=\))\s*\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'

1276+ captures:

1277+ 0: punctuation.definition.string.begin.tsx

1278+ push:

1279+ - meta_scope: string.regexp.tsx

1280+ - match: "(/)([dgimsuy]*)"

1281+ captures:

1282+ 1: punctuation.definition.string.end.tsx

1283+ 2: keyword.other.tsx

1284+ pop: true

1285+ - include: regexp

1286+ - include: statements

11201287 import-declaration:

1121− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(import)(?!\s*[:\(])(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

1288+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(import)(?:\s+(type)(?!\s+from))?(?!\s*[:\(])(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

11221289 captures:

11231290 1: keyword.control.export.tsx

1124− 2: keyword.control.import.tsx

1291+ 2: storage.modifier.tsx

1292+ 3: keyword.control.import.tsx

1293+ 4: keyword.control.type.tsx

11251294 push:

11261295 - meta_scope: meta.import.tsx

11271296 - match: '(?<!^import|[^\._$[:alnum:]]import)(?=;|$|^)'

11281297 pop: true

1298+ - include: single-line-comment-consuming-line-ending

11291299 - include: comment

11301300 - include: string

11311301 - match: '(?<=^import|[^\._$[:alnum:]]import)(?!\s*["''])'

@@ -1137,14 +1307,16 @@ contexts:

11371307 - include: import-export-declaration

11381308 - include: import-export-declaration

11391309 import-equals-declaration:

1140− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(require)\s*(\()'

1310+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(import)(?:\s+(type))?\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(require)\s*(\()'

11411311 captures:

11421312 1: keyword.control.export.tsx

1143− 2: keyword.control.import.tsx

1144− 3: variable.other.readwrite.alias.tsx

1145− 4: keyword.operator.assignment.tsx

1146− 5: keyword.control.require.tsx

1147− 6: meta.brace.round.tsx

1313+ 2: storage.modifier.tsx

1314+ 3: keyword.control.import.tsx

1315+ 4: keyword.control.type.tsx

1316+ 5: variable.other.readwrite.alias.tsx

1317+ 6: keyword.operator.assignment.tsx

1318+ 7: keyword.control.require.tsx

1319+ 8: meta.brace.round.tsx

11481320 push:

11491321 - meta_scope: meta.import-equals.external.tsx

11501322 - match: \)

@@ -1153,16 +1325,19 @@ contexts:

11531325 pop: true

11541326 - include: comment

11551327 - include: string

1156− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(?!require\b)'

1328+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(import)(?:\s+(type))?\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(?!require\b)'

11571329 captures:

11581330 1: keyword.control.export.tsx

1159− 2: keyword.control.import.tsx

1160− 3: variable.other.readwrite.alias.tsx

1161− 4: keyword.operator.assignment.tsx

1331+ 2: storage.modifier.tsx

1332+ 3: keyword.control.import.tsx

1333+ 4: keyword.control.type.tsx

1334+ 5: variable.other.readwrite.alias.tsx

1335+ 6: keyword.operator.assignment.tsx

11621336 push:

11631337 - meta_scope: meta.import-equals.internal.tsx

11641338 - match: (?=;|$|^)

11651339 pop: true

1340+ - include: single-line-comment-consuming-line-ending

11661341 - include: comment

11671342 - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))'

11681343 captures:

@@ -1184,7 +1359,7 @@ contexts:

11841359 - include: import-export-clause

11851360 import-export-clause:

11861361 - include: comment

11881363 captures:

11891364 1: keyword.control.default.tsx

11901365 2: constant.language.import-export-all.tsx

@@ -1236,6 +1411,9 @@ contexts:

12361411 2: keyword.operator.type.modifier.tsx

12371412 3: keyword.operator.optional.tsx

12381413 pop: true

1414+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+'

1415+ captures:

1416+ 1: keyword.control.as.tsx

12391417 - include: type

12401418 inline-tags:

12411419 - match: '(\[)[^\]]+(\])(?={@(?:link|linkcode|linkplain|tutorial))'

@@ -1267,15 +1445,16 @@ contexts:

12671445 captures:

12681446 1: keyword.operator.expression.instanceof.tsx

12691447 push:

1270− - match: '(?<=\))|(?=[;),}\]:?]|\|\||\&\&|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(]))))'

1448+ - match: '(?<=\))|(?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|(([\&\~\^\|]\s*)?[_$[:alpha:]][_$[:alnum:]]*\s+instanceof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(]))))'

12711449 pop: true

12721450 - include: type

12731451 interface-declaration:

1274− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(export)\s+)?\b(?:(abstract)\s+)?\b(interface)\b(?=\s+|/[/*])'

1452+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(?:(abstract)\s+)?\b(interface)\b(?=\s+|/[/*])'

12751453 captures:

12761454 1: keyword.control.export.tsx

12771455 2: storage.modifier.tsx

1278− 3: storage.type.interface.tsx

1456+ 3: storage.modifier.tsx

1457+ 4: storage.type.interface.tsx

12791458 push:

12801459 - meta_scope: meta.interface.tsx

12811460 - match: '(?<=\})'

@@ -1323,7 +1502,7 @@ contexts:

13231502 captures:

13241503 0: punctuation.section.embedded.begin.tsx

13251504 push:

1326− - meta_scope: meta.embedded.expression.tsx

1505+ - meta_content_scope: meta.embedded.expression.tsx

13271506 - match: '\}'

13281507 captures:

13291508 0: punctuation.section.embedded.end.tsx

@@ -1352,10 +1531,10 @@ contexts:

13521531 pop: true

13531532 - include: jsx-entities

13541533 jsx-tag:

1355− - match: '(?=(<)\s*(?:([_$[:alpha:]][-$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>))'

1534+ - match: '(?=(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>))'

13561535 push:

13571536 - meta_scope: meta.tag.tsx

1358− - match: '(/>)|(?:(</)\s*(?:([_$[:alpha:]][-$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-$[:alnum:].]*))(?<!\.|-))?\s*(>))'

1537+ - match: '(/>)|(?:(</)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>))'

13591538 captures:

13601539 1: punctuation.definition.tag.end.tsx

13611540 2: punctuation.definition.tag.begin.tsx

@@ -1365,7 +1544,7 @@ contexts:

13651544 6: support.class.component.tsx

13661545 7: punctuation.definition.tag.end.tsx

13671546 pop: true

1368− - match: '(<)\s*(?:([_$[:alpha:]][-$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>)'

1547+ - match: '(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>)'

13691548 captures:

13701549 1: punctuation.definition.tag.begin.tsx

13711550 2: entity.name.tag.namespace.tsx

@@ -1393,8 +1572,8 @@ contexts:

13931572 - match: |-

13941573 (?x)

13951574 \s*

1396− (?:([_$[:alpha:]][-$[:alnum:].]*)(:))?

1397− ([_$[:alpha:]][-$[:alnum:]]*)

1575+ (?:([_$[:alpha:]][-_$[:alnum:].]*)(:))?

1576+ ([_$[:alpha:]][-_$[:alnum:]]*)

13981577 (?=\s|=|/?>|/\*|//)

13991578 captures:

14001579 1: entity.other.attribute-name.namespace.tsx

@@ -1419,15 +1598,15 @@ contexts:

14191598 jsx-tag-in-expression:

14201599 - match: |-

14211600 (?x)

1422− (?<!\+\+|--)(?<=[({\[,?=>:*]|&&|\|\||\?|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^default|[^\._$[:alnum:]]default|^yield|[^\._$[:alnum:]]yield|^)\s*

1601+ (?<!\+\+|--)(?<=[({\[,?=>:*]|&&|\|\||\?|\*\/|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^default|[^\._$[:alnum:]]default|^yield|[^\._$[:alnum:]]yield|^)\s*

14231602 (?!<\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s+[^=>])|,)) # look ahead is not type parameter of arrow

1424− (?=(<)\s*(?:([_$[:alpha:]][-$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>))

1603+ (?=(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>))

14251604 push:

1426− - match: '(?!(<)\s*(?:([_$[:alpha:]][-$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>))'

1605+ - match: '(?!(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>))'

14271606 pop: true

14281607 - include: jsx-tag

14291608 jsx-tag-without-attributes:

1430− - match: '(<)\s*(?:([_$[:alpha:]][-$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-$[:alnum:].]*))(?<!\.|-))?\s*(>)'

1609+ - match: '(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>)'

14311610 captures:

14321611 1: punctuation.definition.tag.begin.tsx

14331612 2: entity.name.tag.namespace.tsx

@@ -1438,7 +1617,7 @@ contexts:

14381617 push:

14391618 - meta_scope: meta.tag.without-attributes.tsx

14401619 - meta_content_scope: meta.jsx.children.tsx

1441− - match: '(</)\s*(?:([_$[:alpha:]][-$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-$[:alnum:].]*))(?<!\.|-))?\s*(>)'

1620+ - match: '(</)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>)'

14421621 captures:

14431622 1: punctuation.definition.tag.begin.tsx

14441623 2: entity.name.tag.namespace.tsx

@@ -1449,9 +1628,9 @@ contexts:

14491628 pop: true

14501629 - include: jsx-children

14511630 jsx-tag-without-attributes-in-expression:

1452− - match: '(?<!\+\+|--)(?<=[({\[,?=>:*]|&&|\|\||\?|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^default|[^\._$[:alnum:]]default|^yield|[^\._$[:alnum:]]yield|^)\s*(?=(<)\s*(?:([_$[:alpha:]][-$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-$[:alnum:].]*))(?<!\.|-))?\s*(>))'

1631+ - match: '(?<!\+\+|--)(?<=[({\[,?=>:*]|&&|\|\||\?|\*\/|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^default|[^\._$[:alnum:]]default|^yield|[^\._$[:alnum:]]yield|^)\s*(?=(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>))'

14531632 push:

1454− - match: '(?!(<)\s*(?:([_$[:alpha:]][-$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-$[:alnum:].]*))(?<!\.|-))?\s*(>))'

1633+ - match: '(?!(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>))'

14551634 pop: true

14561635 - include: jsx-tag-without-attributes

14571636 label:

@@ -1477,25 +1656,27 @@ contexts:

14771656 - include: this-literal

14781657 - include: super-literal

14791658 method-declaration:

1480− - match: '(?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?\s*\b(constructor)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

1659+ - match: '(?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?\s*\b(constructor)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

14811660 captures:

14821661 1: storage.modifier.tsx

14831662 2: storage.modifier.tsx

1484− 3: storage.modifier.async.tsx

1485− 4: storage.type.tsx

1663+ 3: storage.modifier.tsx

1664+ 4: storage.modifier.async.tsx

1665+ 5: storage.type.tsx

14861666 push:

14871667 - meta_scope: meta.method.declaration.tsx

14881668 - match: '(?=\}|;|,|$)|(?<=\})'

14891669 pop: true

14901670 - include: method-declaration-name

14911671 - include: function-body

1672+ - 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*))?[\(])'

14931673 captures:

14941674 1: storage.modifier.tsx

14951675 2: storage.modifier.tsx

1496− 3: storage.modifier.async.tsx

1497− 4: keyword.operator.new.tsx

1498− 5: keyword.generator.asterisk.tsx

1676+ 3: storage.modifier.tsx

1677+ 4: storage.modifier.async.tsx

1678+ 5: keyword.operator.new.tsx

1679+ 6: keyword.generator.asterisk.tsx

14991680 push:

15001681 - meta_scope: meta.method.declaration.tsx

15011682 - match: '(?=\}|;|,|$)|(?<=\})'

@@ -1503,22 +1684,23 @@ contexts:

15031684 - include: method-declaration-name

15041685 - include: function-body

15051686 - match: |-

1506− (?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_]*\b(?!\$))|(\b(?<!\$)0(b|B)[01][01_]*\b(?!\$))|(\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$))|((?<!\$)(?:

1507− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1508− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1509− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1510− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1511− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1512− (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1513− (?:\B(\.)[0-9][0-9_]*\b)| # .1

1514− (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1515− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*[\(\<])

1687+ (?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(?!\$))|((?<!\$)(?:

1688+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3

1689+ (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3

1690+ (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3

1691+ (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3

1692+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1

1693+ (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

1694+ (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

1695+ (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

1696+ )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])

15161697 captures:

15171698 1: storage.modifier.tsx

15181699 2: storage.modifier.tsx

1519− 3: storage.modifier.async.tsx

1520− 4: storage.type.property.tsx

1521− 5: keyword.generator.asterisk.tsx

1700+ 3: storage.modifier.tsx

1701+ 4: storage.modifier.async.tsx

1702+ 5: storage.type.property.tsx

1703+ 6: keyword.generator.asterisk.tsx

15221704 push:

15231705 - meta_scope: meta.method.declaration.tsx

15241706 - match: '(?=\}|;|,|$)|(?<=\})'

@@ -1527,16 +1709,16 @@ contexts:

15271709 - include: function-body

15281710 method-declaration-name:

15291711 - match: |-

1530− (?x)(?=((\b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$))|(\b(?<!\$)0(b|B)[01][01_]*\b(?!\$))|(\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$))|((?<!\$)(?:

1531− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1532− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1533− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1534− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1535− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1536− (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1537− (?:\B(\.)[0-9][0-9_]*\b)| # .1

1538− (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1539− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??)\s*[\(\<])

1712+ (?x)(?=((\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(?!\$))|((?<!\$)(?:

1713+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3

1714+ (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3

1715+ (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3

1716+ (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3

1717+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1

1718+ (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

1719+ (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

1720+ (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

1721+ )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??)\s*[\(\<])

15401722 push:

15411723 - match: (?=\(|\<)

15421724 pop: true

@@ -1548,13 +1730,14 @@ contexts:

15481730 - match: \?

15491731 scope: keyword.operator.optional.tsx

15501732 namespace-declaration:

1551− - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(namespace|module)\s+(?=[_$[:alpha:]"''`]))'

1733+ - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(namespace|module)\s+(?=[_$[:alpha:]"''`]))'

15521734 captures:

15531735 1: keyword.control.export.tsx

1554− 2: storage.type.namespace.tsx

1736+ 2: storage.modifier.tsx

1737+ 3: storage.type.namespace.tsx

15551738 push:

15561739 - meta_scope: meta.namespace.declaration.tsx

1557− - match: '(?<=\})|(?=;|^\s*abstract\b|^\s*async\b|^\s*class\b|^\s*const\b|^\s*declare\b|^\s*enum\b|^\s*export\b|^\s*function\b|^\s*import\b|^\s*interface\b|^\s*let\b|^\s*module\b|^\s*namespace\b|^\s*return\b|^\s*type\b|^\s*var\b)'

1740+ - match: '(?<=\})|(?=;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

15581741 pop: true

15591742 - include: comment

15601743 - include: string

@@ -1568,41 +1751,53 @@ contexts:

15681751 1: keyword.operator.new.tsx

15691752 push:

15701753 - meta_scope: new.expr.tsx

1571− - match: '(?<=\))|(?=[;),}\]:]|\|\||\&\&|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(]))))'

1754+ - match: '(?<=\))|(?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(]))))'

15721755 pop: true

1573− - include: paren-expression

1574− - include: class-declaration

1575− - include: type

1756+ - include: expression

15761757 null-literal:

15771758 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))null(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

15781759 scope: constant.language.null.tsx

15791760 numeric-literal:

1580− - match: '\b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$)'

1761+ - match: '\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$)'

15811762 scope: constant.numeric.hex.tsx

1582− - match: '\b(?<!\$)0(b|B)[01][01_]*\b(?!\$)'

1763+ captures:

1764+ 1: storage.type.numeric.bigint.tsx

1765+ - match: '\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$)'

15831766 scope: constant.numeric.binary.tsx

1584− - match: '\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$)'

1767+ captures:

1768+ 1: storage.type.numeric.bigint.tsx

1769+ - match: '\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$)'

15851770 scope: constant.numeric.octal.tsx

1771+ captures:

1772+ 1: storage.type.numeric.bigint.tsx

15861773 - match: |-

15871774 (?x)

15881775 (?<!\$)(?:

1589− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1590− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1591− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1592− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1593− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1594− (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1595− (?:\B(\.)[0-9][0-9_]*\b)| # .1

1596− (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1776+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3

1777+ (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3

1778+ (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3

1779+ (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3

1780+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1

1781+ (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

1782+ (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

1783+ (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

15971784 )(?!\$)

15981785 captures:

15991786 0: constant.numeric.decimal.tsx

16001787 1: meta.delimiter.decimal.period.tsx

1601− 2: meta.delimiter.decimal.period.tsx

1788+ 2: storage.type.numeric.bigint.tsx

16021789 3: meta.delimiter.decimal.period.tsx

1603− 4: meta.delimiter.decimal.period.tsx

1790+ 4: storage.type.numeric.bigint.tsx

16041791 5: meta.delimiter.decimal.period.tsx

1605− 6: meta.delimiter.decimal.period.tsx

1792+ 6: storage.type.numeric.bigint.tsx

1793+ 7: storage.type.numeric.bigint.tsx

1794+ 8: meta.delimiter.decimal.period.tsx

1795+ 9: storage.type.numeric.bigint.tsx

1796+ 10: meta.delimiter.decimal.period.tsx

1797+ 11: storage.type.numeric.bigint.tsx

1798+ 12: meta.delimiter.decimal.period.tsx

1799+ 13: storage.type.numeric.bigint.tsx

1800+ 14: storage.type.numeric.bigint.tsx

16061801 numericConstant-literal:

16071802 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))NaN(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

16081803 scope: constant.language.nan.tsx

@@ -1611,16 +1806,16 @@ contexts:

16111806 object-binding-element:

16121807 - include: comment

16131808 - match: |-

1614− (?x)(?=((\b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$))|(\b(?<!\$)0(b|B)[01][01_]*\b(?!\$))|(\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$))|((?<!\$)(?:

1615− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1616− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1617− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1618− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1619− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1620− (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1621− (?:\B(\.)[0-9][0-9_]*\b)| # .1

1622− (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1623− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))

1809+ (?x)(?=((\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(?!\$))|((?<!\$)(?:

1810+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3

1811+ (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3

1812+ (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3

1813+ (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3

1814+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1

1815+ (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

1816+ (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

1817+ (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

1818+ )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))

16241819 push:

16251820 - match: '(?=,|\})'

16261821 pop: true

@@ -1633,16 +1828,16 @@ contexts:

16331828 object-binding-element-const:

16341829 - include: comment

16351830 - match: |-

1636− (?x)(?=((\b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$))|(\b(?<!\$)0(b|B)[01][01_]*\b(?!\$))|(\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$))|((?<!\$)(?:

1637− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1638− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1639− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1640− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1641− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1642− (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1643− (?:\B(\.)[0-9][0-9_]*\b)| # .1

1644− (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1645− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))

1831+ (?x)(?=((\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(?!\$))|((?<!\$)(?:

1832+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3

1833+ (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3

1834+ (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3

1835+ (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3

1836+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1

1837+ (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

1838+ (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

1839+ (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

1840+ )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))

16461841 push:

16471842 - match: '(?=,|\})'

16481843 pop: true

@@ -1654,16 +1849,16 @@ contexts:

16541849 - include: punctuation-comma

16551850 object-binding-element-propertyName:

16561851 - match: |-

1657− (?x)(?=((\b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$))|(\b(?<!\$)0(b|B)[01][01_]*\b(?!\$))|(\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$))|((?<!\$)(?:

1658− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1659− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1660− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1661− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1662− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1663− (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1664− (?:\B(\.)[0-9][0-9_]*\b)| # .1

1665− (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1666− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))

1852+ (?x)(?=((\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(?!\$))|((?<!\$)(?:

1853+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3

1854+ (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3

1855+ (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3

1856+ (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3

1857+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1

1858+ (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

1859+ (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

1860+ (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

1861+ )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))

16671862 push:

16681863 - match: (:)

16691864 captures:

@@ -1701,9 +1896,9 @@ contexts:

17011896 scope: support.class.tsx

17021897 - match: |-

17031898 (?x)(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(?:

1704− ([[:upper:]][_$[:digit:][:upper:]]*) |

1705− ([_$[:alpha:]][_$[:alnum:]]*)

1706− )(?=\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)

1899+ (\#?[[:upper:]][_$[:digit:][:upper:]]*) |

1900+ (\#?[_$[:alpha:]][_$[:alnum:]]*)

1901+ )(?=\s*\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*)

17071902 captures:

17081903 1: punctuation.accessor.tsx

17091904 2: punctuation.accessor.optional.tsx

@@ -1713,7 +1908,7 @@ contexts:

17131908 (?x)(?:

17141909 ([[:upper:]][_$[:digit:][:upper:]]*) |

17151910 ([_$[:alpha:]][_$[:alnum:]]*)

1716− )(?=\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)

1911+ )(?=\s*\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*)

17171912 captures:

17181913 1: variable.other.constant.object.tsx

17191914 2: variable.other.object.tsx

@@ -1730,16 +1925,16 @@ contexts:

17301925 - include: object-member

17311926 object-literal-method-declaration:

17321927 - match: |-

1733− (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=\s*(((\b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$))|(\b(?<!\$)0(b|B)[01][01_]*\b(?!\$))|(\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$))|((?<!\$)(?:

1734− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1735− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1736− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1737− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1738− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1739− (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1740− (?:\B(\.)[0-9][0-9_]*\b)| # .1

1741− (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1742− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*[\(\<])

1928+ (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\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(?!\$))|((?<!\$)(?:

1929+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3

1930+ (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3

1931+ (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3

1932+ (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3

1933+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1

1934+ (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

1935+ (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

1936+ (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

1937+ )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])

17431938 captures:

17441939 1: storage.modifier.async.tsx

17451940 2: storage.type.property.tsx

@@ -1751,16 +1946,16 @@ contexts:

17511946 - include: method-declaration-name

17521947 - include: function-body

17531948 - match: |-

1754− (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=\s*(((\b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$))|(\b(?<!\$)0(b|B)[01][01_]*\b(?!\$))|(\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$))|((?<!\$)(?:

1755− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1756− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1757− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1758− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1759− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1760− (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1761− (?:\B(\.)[0-9][0-9_]*\b)| # .1

1762− (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1763− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*[\(\<])

1949+ (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\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(?!\$))|((?<!\$)(?:

1950+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3

1951+ (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3

1952+ (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3

1953+ (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3

1954+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1

1955+ (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

1956+ (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

1957+ (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

1958+ )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])

17641959 captures:

17651960 1: storage.modifier.async.tsx

17661961 2: storage.type.property.tsx

@@ -1777,37 +1972,56 @@ contexts:

17771972 - meta_scope: meta.object.member.tsx meta.object-literal.key.tsx

17781973 - match: '(?=:)|((?<=[\]])(?=\s*[\(\<]))'

17791974 pop: true

1975+ - include: comment

17801976 - include: array-literal

1781− - match: '(?=[\''\"])'

1977+ - match: '(?=[\''\"\`])'

17821978 push:

17831979 - meta_scope: meta.object.member.tsx meta.object-literal.key.tsx

1784− - match: '(?=:)|((?<=[\''\"])(?=\s*[\(\<]))'

1980+ - match: '(?=:)|((?<=[\''\"\`])(?=((\s*[\(\<,}])|(\s+(as)\s+))))'

17851981 pop: true

1982+ - include: comment

17861983 - include: string

1787− - match: '(?<=[\]\''\"])(?=\s*[\(\<])'

1984+ - match: |-

1985+ (?x)(?=(\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(?!\$))|((?<!\$)(?:

1986+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3

1987+ (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3

1988+ (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3

1989+ (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3

1990+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1

1991+ (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

1992+ (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

1993+ (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

1994+ )(?!\$)))

1995+ push:

1996+ - meta_scope: meta.object.member.tsx meta.object-literal.key.tsx

1997+ - match: '(?=:)|(?=\s*([\(\<,}])|(\s+as\s+))'

1998+ pop: true

1999+ - include: comment

2000+ - include: numeric-literal

2001+ - match: '(?<=[\]\''\"\`])(?=\s*[\(\<])'

17882002 push:

17892003 - meta_scope: meta.method.declaration.tsx

17902004 - match: '(?=\}|;|,)|(?<=\})'

17912005 pop: true

17922006 - include: function-body

1793− - match: '(?![_$[:alpha:]])([[:digit:]]+)\s*(?=:)'

2007+ - match: '(?![_$[:alpha:]])([[:digit:]]+)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:)'

17942008 scope: meta.object.member.tsx

17952009 captures:

17962010 0: meta.object-literal.key.tsx

17972011 1: constant.numeric.decimal.tsx

17982012 - match: |-

1799− (?x)(?:([_$[:alpha:]][_$[:alnum:]]*)\s*(?=:\s*(

2013+ (?x)(?:([_$[:alpha:]][_$[:alnum:]]*)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:(\s*\/\*([^\*]|(\*[^\/]))*\*\/)*\s*(

18002014 ((async\s+)?(

18012015 (function\s*[(<*]) |

18022016 (function\s+) |

18032017 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

18042018 )) |

18052019 ((async\s*)?(

1806− ((<\s*$)|([\(]\s*([\{\[]\s*)?$)) |

2020+ ((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

18072021 # sure shot arrow functions even if => is on new line

18082022 (

1809− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

1810− [(]\s*

2023+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

2024+ [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

18112025 (

18122026 ([)]\s*:) | # ():

18132027 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

@@ -1818,9 +2032,9 @@ contexts:

18182032 ) |

18192033 # arrow function possible to detect only with => on same line

18202034 (

1821− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

1822− $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

1823− (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

2035+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

2036+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

2037+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

18242038 \s*=> # arrow operator

18252039 )

18262040 ))

@@ -1829,7 +2043,7 @@ contexts:

18292043 captures:

18302044 0: meta.object-literal.key.tsx

18312045 1: entity.name.function.tsx

1832− - match: '(?:[_$[:alpha:]][_$[:alnum:]]*)\s*(?=:)'

2046+ - match: '(?:[_$[:alpha:]][_$[:alnum:]]*)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:)'

18332047 scope: meta.object.member.tsx

18342048 captures:

18352049 0: meta.object-literal.key.tsx

@@ -1841,14 +2055,27 @@ contexts:

18412055 - match: '(?=,|\})'

18422056 pop: true

18432057 - include: expression

1844− - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?=,|\}|$)'

2058+ - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?=,|\}|$|\/\/|\/\*)'

18452059 scope: meta.object.member.tsx

18462060 captures:

18472061 1: variable.other.readwrite.tsx

2062+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+(const)(?=\s*([,}]|$))'

2063+ scope: meta.object.member.tsx

2064+ captures:

2065+ 1: keyword.control.as.tsx

2066+ 2: storage.modifier.tsx

2067+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+'

2068+ captures:

2069+ 1: keyword.control.as.tsx

2070+ push:

2071+ - meta_scope: meta.object.member.tsx

2072+ - match: '(?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|^|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+))'

2073+ pop: true

2074+ - include: type

18482075 - match: '(?=[_$[:alpha:]][_$[:alnum:]]*\s*=)'

18492076 push:

18502077 - meta_scope: meta.object.member.tsx

1851− - match: '(?=,|\}|$)'

2078+ - match: '(?=,|\}|$|\/\/|\/\*)'

18522079 pop: true

18532080 - include: expression

18542081 - match: ":"

@@ -1858,7 +2085,7 @@ contexts:

18582085 - meta_scope: meta.object.member.tsx

18592086 - match: '(?=,|\})'

18602087 pop: true

1861− - match: '(?<=:)\s*(async)?(?=\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)\(\s*([\{\[]\s*)?$)'

2088+ - match: '(?<=:)\s*(async)?(?=\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)$\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'

18622089 captures:

18632090 1: storage.modifier.async.tsx

18642091 push:

@@ -1874,7 +2101,7 @@ contexts:

18742101 0: meta.brace.round.tsx

18752102 pop: true

18762103 - include: expression-inside-possibly-arrow-parens

1877− - match: '(?<=:)\s*(async)?\s*(\()(?=\s*([\{\[]\s*)?$)'

2104+ - match: '(?<=:)\s*(async)?\s*($)(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'

18782105 captures:

18792106 1: storage.modifier.async.tsx

18802107 2: meta.brace.round.tsx

@@ -1884,6 +2111,23 @@ contexts:

18842111 0: meta.brace.round.tsx

18852112 pop: true

18862113 - include: expression-inside-possibly-arrow-parens

2114+ - match: (?<=:)\s*(async)?\s*(?=\<\s*$)

2115+ captures:

2116+ 1: storage.modifier.async.tsx

2117+ push:

2118+ - match: (?<=\>)

2119+ pop: true

2120+ - include: type-parameters

2121+ - match: '(?<=\>)\s*($)(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'

2122+ captures:

2123+ 1: meta.brace.round.tsx

2124+ push:

2125+ - match: \)

2126+ captures:

2127+ 0: meta.brace.round.tsx

2128+ pop: true

2129+ - include: expression-inside-possibly-arrow-parens

2130+ - include: possibly-arrow-return-type

18872131 - include: expression

18882132 - include: punctuation-comma

18892133 parameter-array-binding-pattern:

@@ -1901,16 +2145,18 @@ contexts:

19012145 parameter-binding-element:

19022146 - include: comment

19032147 - include: string

2148+ - include: numeric-literal

2149+ - include: regex

19042150 - include: parameter-object-binding-pattern

19052151 - include: parameter-array-binding-pattern

19062152 - include: destructuring-parameter-rest

19072153 - include: variable-initializer

19082154 parameter-name:

19102156 captures:

19112157 1: storage.modifier.tsx

19122158 - match: |-

19142160 # function assignment |

19152161 (=\s*(

19162162 ((async\s+)?(

@@ -1919,11 +2165,11 @@ contexts:

19192165 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

19202166 )) |

19212167 ((async\s*)?(

1922− ((<\s*$)|([\(]\s*([\{\[]\s*)?$)) |

2168+ ((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

19232169 # sure shot arrow functions even if => is on new line

19242170 (

1925− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

1926− [(]\s*

2171+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

2172+ [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

19272173 (

19282174 ([)]\s*:) | # ():

19292175 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

@@ -1934,9 +2180,9 @@ contexts:

19342180 ) |

19352181 # arrow function possible to detect only with => on same line

19362182 (

1937− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

1938− $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

1939− (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

2183+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

2184+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

2185+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

19402186 \s*=> # arrow operator

19412187 )

19422188 ))

@@ -1953,19 +2199,20 @@ contexts:

19532199 ))

19542200 ))

19552201 )) |

1956− (:\s*((<\s*$)|([\(]\s*([\{\[]\s*)?$))) |

1957− (:\s*(=>|($([^\($]|($[^\($]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

2202+ (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |

2203+ (:\s*((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

2204+ (:\s*(=>|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

19582205 ((async\s+)?(

19592206 (function\s*[(<*]) |

19602207 (function\s+) |

19612208 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

19622209 )) |

19632210 ((async\s*)?(

1964− ((<\s*$)|([\(]\s*([\{\[]\s*)?$)) |

2211+ ((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

19652212 # sure shot arrow functions even if => is on new line

19662213 (

1967− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

1968− [(]\s*

2214+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

2215+ [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

19692216 (

19702217 ([)]\s*:) | # ():

19712218 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

@@ -1976,9 +2223,9 @@ contexts:

19762223 ) |

19772224 # arrow function possible to detect only with => on same line

19782225 (

1979− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

1980− $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

1981− (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

2226+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

2227+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

2228+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

19822229 \s*=> # arrow operator

19832230 )

19842231 ))

@@ -1989,7 +2236,7 @@ contexts:

19892236 3: entity.name.function.tsx variable.language.this.tsx

19902237 4: entity.name.function.tsx

19912238 5: keyword.operator.optional.tsx

19932240 captures:

19942241 1: storage.modifier.tsx

19952242 2: keyword.operator.rest.tsx

@@ -1999,16 +2246,16 @@ contexts:

19992246 parameter-object-binding-element:

20002247 - include: comment

20012248 - match: |-

2002− (?x)(?=((\b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$))|(\b(?<!\$)0(b|B)[01][01_]*\b(?!\$))|(\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$))|((?<!\$)(?:

2003− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

2004− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

2005− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

2006− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

2007− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

2008− (?:\b[0-9][0-9_]*(\.)\B)| # 1.

2009− (?:\B(\.)[0-9][0-9_]*\b)| # .1

2010− (?:\b[0-9][0-9_]*\b(?!\.)) # 1

2011− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))

2249+ (?x)(?=((\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(?!\$))|((?<!\$)(?:

2250+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3

2251+ (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3

2252+ (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3

2253+ (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3

2254+ (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1

2255+ (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.

2256+ (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1

2257+ (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1

2258+ )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))

20122259 push:

20132260 - match: '(?=,|\})'

20142261 pop: true

@@ -2029,6 +2276,15 @@ contexts:

20292276 0: punctuation.definition.binding-pattern.object.tsx

20302277 pop: true

20312278 - include: parameter-object-binding-element

2279+ parameter-type-annotation:

2280+ - match: (:)

2281+ captures:

2282+ 1: keyword.operator.type.annotation.tsx

2283+ push:

2284+ - meta_scope: meta.type.annotation.tsx

2285+ - match: "(?=[,)])|(?==[^>])"

2286+ pop: true

2287+ - include: type

20322288 paren-expression:

20332289 - match: \(

20342290 captures:

@@ -2040,14 +2296,14 @@ contexts:

20402296 pop: true

20412297 - include: expression

20422298 paren-expression-possibly-arrow:

2043− - match: '(?<=[(=,])\s*(async)?(?=\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*))?\(\s*[\{\[]\s*$)'

2299+ - match: '(?<=[(=,])\s*(async)?(?=\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?$\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'

20442300 captures:

20452301 1: storage.modifier.async.tsx

20462302 push:

20472303 - match: (?<=\))

20482304 pop: true

20492305 - include: paren-expression-possibly-arrow-with-typeparameters

2050− - match: '(?<=[(=,]|=>)\s*(async)?(?=\s*((((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*))?\()|(<))\s*$)'

2306+ - match: '(?<=[(=,]|=>|^return|[^\._$[:alnum:]]return)\s*(async)?(?=\s*((((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\()|(<))\s*$)'

20512307 captures:

20522308 1: storage.modifier.async.tsx

20532309 push:

@@ -2067,7 +2323,7 @@ contexts:

20672323 pop: true

20682324 - include: expression-inside-possibly-arrow-parens

20692325 possibly-arrow-return-type:

2070− - match: '(?<=\))\s*(:)(?=\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+\s*=>)'

2326+ - match: '(?<=\)|^)\s*(:)(?=\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*=>)'

20712327 captures:

20722328 1: meta.arrow.tsx meta.return.type.arrow.tsx keyword.operator.type.annotation.tsx

20732329 push:

@@ -2114,23 +2370,23 @@ contexts:

21142370 pop: true

21152371 - include: string-character-escape

21162372 regex:

2117− - match: '(?<!\+\+|--|})(?<=[=(:,\[?+!]|^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/[gimsuy]*(?!\s*[a-zA-Z0-9_$]))'

2373+ - match: '(?<!\+\+|--|})(?<=[=(:,\[?+!]|^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[$)]|\\.|\[([^\]\\]|\\.)+\]|\(([^$\\]|\\.)+\))+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'

21182374 captures:

21192375 1: punctuation.definition.string.begin.tsx

21202376 push:

21212377 - meta_scope: string.regexp.tsx

2122− - match: "(/)([gimsuy]*)"

2378+ - match: "(/)([dgimsuy]*)"

21232379 captures:

21242380 1: punctuation.definition.string.end.tsx

21252381 2: keyword.other.tsx

21262382 pop: true

21272383 - include: regexp

2128− - match: '(?<![_$[:alnum:])\]]|\+\+|--|})\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/[gimsuy]*(?!\s*[a-zA-Z0-9_$]))'

2384+ - match: '((?<![_$[:alnum:])\]]|\+\+|--|}|\*\/)|((?<=^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case))\s*)\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'

21292385 captures:

21302386 0: punctuation.definition.string.begin.tsx

21312387 push:

21322388 - meta_scope: string.regexp.tsx

2133− - match: "(/)([gimsuy]*)"

2389+ - match: "(/)([dgimsuy]*)"

21342390 captures:

21352391 1: punctuation.definition.string.end.tsx

21362392 2: keyword.other.tsx

@@ -2230,10 +2486,24 @@ contexts:

22302486 - include: type-object

22312487 - include: type-predicate-operator

22322488 - include: type

2489+ shebang:

2490+ - match: \A(#!).*(?=$)

2491+ scope: comment.line.shebang.tsx

2492+ captures:

2493+ 1: punctuation.definition.comment.tsx

2494+ single-line-comment-consuming-line-ending:

2495+ - match: '(^[ \t]+)?((//)(?:\s*((@)internal)(?=\s|$))?)'

2496+ captures:

2497+ 1: punctuation.whitespace.comment.leading.tsx

2498+ 2: comment.line.double-slash.tsx

2499+ 3: punctuation.definition.comment.tsx

2500+ 4: storage.type.internaldeclaration.tsx

2501+ 5: punctuation.decorator.internaldeclaration.tsx

2502+ push:

2503+ - meta_content_scope: comment.line.double-slash.tsx

2504+ - match: (?=^)

2505+ pop: true

22332506 statements:

2234− - include: string

2235− - include: template

2236− - include: comment

22372507 - include: declaration

22382508 - include: control-statement

22392509 - include: after-operator-block-as-object-literal

@@ -2241,21 +2511,31 @@ contexts:

22412511 - include: label

22422512 - include: expression

22432513 - include: punctuation-semicolon

2514+ - include: string

2515+ - include: comment

22442516 string:

22452517 - include: qstring-single

22462518 - include: qstring-double

2519+ - include: template

22472520 string-character-escape:

2248− - 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]?|.|$)'

2521+ - match: '\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\{[0-9A-Fa-f]+\}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)'

22492522 scope: constant.character.escape.tsx

22502523 super-literal:

22512524 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))super\b(?!\$)'

22522525 scope: variable.language.super.tsx

2526+ support-function-call-identifiers:

2527+ - include: literal

2528+ - include: support-objects

2529+ - include: object-identifiers

2530+ - include: punctuation-accessor

2531+ - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*[\(]\s*[\"\''\`]))'

2532+ scope: keyword.operator.expression.import.tsx

22532533 support-objects:

22542534 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(arguments)\b(?!\$)'

22552535 scope: variable.language.arguments.tsx

22562536 - match: |-

22612541 scope: support.class.builtin.tsx

@@ -2309,9 +2589,9 @@ contexts:

23092589 4: support.variable.property.target.tsx

23102590 - match: |-

23112591 (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?:

2312− (constructor|length|prototype|__proto__)

2592+ (?:(constructor|length|prototype|__proto__)\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\())

23132593 |

23152595 captures:

23162596 1: punctuation.accessor.tsx

23172597 2: punctuation.accessor.optional.tsx

@@ -2415,7 +2695,7 @@ contexts:

2418− |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?\()

2698+ |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\()

24192699 captures:

24202700 1: punctuation.accessor.tsx

24212701 2: punctuation.accessor.optional.tsx

@@ -2539,6 +2819,7 @@ contexts:

25392819 captures:

25402820 0: punctuation.definition.block.tsx

25412821 pop: true

2822+ - include: comment

25422823 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(switch)\s*(\()'

25432824 captures:

25442825 1: keyword.control.switch.tsx

@@ -2581,7 +2862,34 @@ contexts:

25812862 0: case-clause.expr.tsx punctuation.definition.section.case-statement.tsx

25822863 - include: statements

25832864 template:

2584− - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?=(<\s*(((keyof|infer)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))(?=\s*([\<\>\,\.\[=]|&(?!&)|\|(?!\|)))))([^<>$]|(\(([^\($]|($[^\($]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))(?=\s*([\<\>\,\.\[=]|&(?!&)|\|(?!\|)))))([^<>$]|(\(([^\($]|($[^\($]*\)))*\))|(?<==)\>)*(?!=)\>)*(?!=)>\s*)`)'

2865+ - include: template-call

2866+ - match: "([_$[:alpha:]][_$[:alnum:]]*)?(`)"

2867+ captures:

2868+ 1: entity.name.function.tagged-template.tsx

2869+ 2: punctuation.definition.string.template.begin.tsx

2870+ push:

2871+ - meta_scope: string.template.tsx

2872+ - match: "`"

2873+ captures:

2874+ 0: punctuation.definition.string.template.end.tsx

2875+ pop: true

2876+ - include: template-substitution-element

2877+ - include: string-character-escape

2878+ template-call:

2879+ - 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*)?`)'

2880+ push:

2881+ - meta_scope: string.template.tsx

2882+ - match: (?=`)

2883+ pop: true

2884+ - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*))'

2885+ push:

2886+ - 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*)?`)'

2887+ pop: true

2888+ - include: support-function-call-identifiers

2889+ - match: "([_$[:alpha:]][_$[:alnum:]]*)"

2890+ scope: entity.name.function.tagged-template.tsx

2891+ - include: type-arguments

2892+ - 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*)`)'

25852893 captures:

25862894 1: entity.name.function.tagged-template.tsx

25872895 push:

@@ -2589,6 +2897,20 @@ contexts:

25892897 - match: (?=`)

25902898 pop: true

25912899 - include: type-arguments

2900+ template-substitution-element:

2901+ - match: '\$\{'

2902+ captures:

2903+ 0: punctuation.definition.template-expression.begin.tsx

2904+ push:

2905+ - meta_scope: meta.template.expression.tsx

2906+ - meta_content_scope: meta.embedded.line.tsx

2907+ - match: '\}'

2908+ captures:

2909+ 0: punctuation.definition.template-expression.end.tsx

2910+ pop: true

2911+ - include: expression

2912+ template-type:

2913+ - include: template-call

25922914 - match: "([_$[:alpha:]][_$[:alnum:]]*)?(`)"

25932915 captures:

25942916 1: entity.name.function.tagged-template.tsx

@@ -2599,9 +2921,9 @@ contexts:

25992921 captures:

26002922 0: punctuation.definition.string.template.end.tsx

26012923 pop: true

2602− - include: template-substitution-element

2924+ - include: template-type-substitution-element

26032925 - include: string-character-escape

2604− template-substitution-element:

2926+ template-type-substitution-element:

26052927 - match: '\$\{'

26062928 captures:

26072929 0: punctuation.definition.template-expression.begin.tsx

@@ -2612,9 +2934,9 @@ contexts:

26122934 captures:

26132935 0: punctuation.definition.template-expression.end.tsx

26142936 pop: true

2615− - include: expression

2937+ - include: type

26162938 ternary-expression:

2617− - match: '(?!\?\.\s*[^[:digit:]])(\?)'

2939+ - match: '(?!\?\.\s*[^[:digit:]])(\?)(?!\?)'

26182940 captures:

26192941 1: keyword.operator.ternary.tsx

26202942 push:

@@ -2628,7 +2950,7 @@ contexts:

26282950 scope: variable.language.this.tsx

26292951 type:

26302952 - include: comment

2631− - include: string

2953+ - include: type-string

26322954 - include: numeric-literal

26332955 - include: type-primitive

26342956 - include: type-builtin-literals

@@ -2640,24 +2962,36 @@ contexts:

26402962 - include: type-fn-type-parameters

26412963 - include: type-paren-or-function-parameters

26422964 - include: type-function-return-type

2965+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*'

2966+ captures:

2967+ 1: storage.modifier.tsx

26432968 - include: type-name

26442969 type-alias-declaration:

2645− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(type)\b\s+([_$[:alpha:]][_$[:alnum:]]*)\s*'

2970+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(type)\b\s+([_$[:alpha:]][_$[:alnum:]]*)\s*'

26462971 captures:

26472972 1: keyword.control.export.tsx

2648− 2: storage.type.type.tsx

2649− 3: entity.name.type.alias.tsx

2973+ 2: storage.modifier.tsx

2974+ 3: storage.type.type.tsx

2975+ 4: entity.name.type.alias.tsx

26502976 push:

26512977 - meta_scope: meta.type.declaration.tsx

2652− - match: '(?=\}|;|^\s*abstract\b|^\s*async\b|^\s*class\b|^\s*const\b|^\s*declare\b|^\s*enum\b|^\s*export\b|^\s*function\b|^\s*import\b|^\s*interface\b|^\s*let\b|^\s*module\b|^\s*namespace\b|^\s*return\b|^\s*type\b|^\s*var\b)'

2978+ - match: '(?=\}|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

26532979 pop: true

26542980 - include: comment

26552981 - include: type-parameters

2982+ - match: '(=)\s*(intrinsic)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

2983+ captures:

2984+ 1: keyword.operator.assignment.tsx

2985+ 2: keyword.control.intrinsic.tsx

2986+ push:

2987+ - match: '(?=\}|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

2988+ pop: true

2989+ - include: type

26562990 - match: (=)\s*

26572991 captures:

26582992 1: keyword.operator.assignment.tsx

26592993 push:

2660− - match: '(?=\}|;|^\s*abstract\b|^\s*async\b|^\s*class\b|^\s*const\b|^\s*declare\b|^\s*enum\b|^\s*export\b|^\s*function\b|^\s*import\b|^\s*interface\b|^\s*let\b|^\s*module\b|^\s*namespace\b|^\s*return\b|^\s*type\b|^\s*var\b)'

2994+ - match: '(?=\}|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

26612995 pop: true

26622996 - include: type

26632997 type-annotation:

@@ -2687,8 +3021,13 @@ contexts:

26873021 captures:

26883022 0: punctuation.definition.typeparameters.end.tsx

26893023 pop: true

2690− - include: type

2691− - include: punctuation-comma

3024+ - include: type-arguments-body

3025+ type-arguments-body:

3026+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(_)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

3027+ captures:

3028+ 0: keyword.operator.type.tsx

3029+ - include: type

3030+ - include: punctuation-comma

26923031 type-builtin-literals:

26943033 scope: support.type.builtin.tsx

@@ -2710,13 +3049,19 @@ contexts:

27103049 - include: type

27113050 - include: type

27123051 type-fn-type-parameters:

2713− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\b(?=\s*\<)'

2714− scope: meta.type.constructor.tsx

3052+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(new)\b(?=\s*\<)'

27153053 captures:

2716− 1: keyword.control.new.tsx

2717− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\b\s*(?=\()'

3054+ 1: meta.type.constructor.tsx storage.modifier.tsx

3055+ 2: meta.type.constructor.tsx keyword.control.new.tsx

3056+ push:

3057+ - match: (?<=>)

3058+ pop: true

3059+ - include: comment

3060+ - include: type-parameters

3061+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(new)\b\s*(?=\()'

27183062 captures:

2719− 1: keyword.control.new.tsx

3063+ 1: storage.modifier.tsx

3064+ 2: keyword.control.new.tsx

27203065 push:

27213066 - meta_scope: meta.type.constructor.tsx

27223067 - match: (?<=\))

@@ -2767,6 +3112,30 @@ contexts:

27673112 - include: type-predicate-operator

27683113 - include: type

27693114 type-name:

3115+ - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(<)'

3116+ captures:

3117+ 1: entity.name.type.module.tsx

3118+ 2: punctuation.accessor.tsx

3119+ 3: punctuation.accessor.optional.tsx

3120+ 4: meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx

3121+ push:

3122+ - meta_content_scope: meta.type.parameters.tsx

3123+ - match: (>)

3124+ captures:

3125+ 1: meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx

3126+ pop: true

3127+ - include: type-arguments-body

3128+ - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(<)'

3129+ captures:

3130+ 1: entity.name.type.tsx

3131+ 2: meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx

3132+ push:

3133+ - meta_content_scope: meta.type.parameters.tsx

3134+ - match: (>)

3135+ captures:

3136+ 1: meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx

3137+ pop: true

3138+ - include: type-arguments-body

27703139 - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))'

27713140 captures:

27723141 1: entity.name.type.module.tsx

@@ -2802,18 +3171,16 @@ contexts:

28023171 - include: type

28033172 type-operators:

28043173 - include: typeof-operator

2805− - match: '(?:([&|])|(=(?!>)))(?=\s*\{)'

3174+ - match: '([&|])(?=\s*\{)'

28063175 captures:

2807− 1: keyword.operator.type.tsx

2808− 2: keyword.operator.assignment.tsx

3176+ 0: keyword.operator.type.tsx

28093177 push:

28103178 - match: '(?<=\})'

28113179 pop: true

28123180 - include: type-object

2813− - match: "([&|])|(=(?!>))"

3181+ - match: "[&|]"

28143182 captures:

2815− 1: keyword.operator.type.tsx

2816− 2: keyword.operator.assignment.tsx

3183+ 0: keyword.operator.type.tsx

28173184 push:

28183185 - match: (?=\S)

28193186 pop: true

@@ -2840,6 +3207,8 @@ contexts:

28403207 scope: storage.modifier.tsx

28413208 - include: type

28423209 - include: punctuation-comma

3210+ - match: (=)(?!>)

3211+ scope: keyword.operator.assignment.tsx

28433212 type-paren-or-function-parameters:

28443213 - match: \(

28453214 captures:

@@ -2850,7 +3219,6 @@ contexts:

28503219 captures:

28513220 0: meta.brace.round.tsx

28523221 pop: true

2853− - include: destructuring-parameter

28543222 - match: |-

28563224 (<) |

@@ -2863,7 +3231,8 @@ contexts:

28633231 ))

28643232 ))

28653233 )) |

2866− (:\s*((<\s*$)|([\(]\s*([\{\[]\s*)?$))))

3234+ (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |

3235+ (:\s*((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))))

28673236 captures:

28683237 1: storage.modifier.tsx

28693238 2: keyword.operator.rest.tsx

@@ -2882,11 +3251,28 @@ contexts:

28823251 scope: punctuation.separator.parameter.tsx

28833252 - include: type

28843253 type-predicate-operator:

3254+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(asserts)\s+)?(?!asserts)(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))\s(is)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

3255+ captures:

3256+ 1: keyword.operator.type.asserts.tsx

3257+ 2: variable.parameter.tsx variable.language.this.tsx

3258+ 3: variable.parameter.tsx

3259+ 4: keyword.operator.expression.is.tsx

3260+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(asserts)\s+(?!is)(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

3261+ captures:

3262+ 1: keyword.operator.type.asserts.tsx

3263+ 2: variable.parameter.tsx variable.language.this.tsx

3264+ 3: variable.parameter.tsx

3265+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))asserts(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

3266+ scope: keyword.operator.type.asserts.tsx

28853267 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))is(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

28863268 scope: keyword.operator.expression.is.tsx

28873269 type-primitive:

28893271 scope: support.type.primitive.tsx

3272+ type-string:

3273+ - include: qstring-single

3274+ - include: qstring-double

3275+ - include: template-type

28903276 type-tuple:

28913277 - match: '\['

28923278 captures:

@@ -2897,56 +3283,84 @@ contexts:

28973283 captures:

28983284 0: meta.brace.square.tsx

28993285 pop: true

3286+ - match: \.\.\.

3287+ scope: keyword.operator.rest.tsx

3288+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))([_$[:alpha:]][_$[:alnum:]]*)\s*(\?)?\s*(:)'

3289+ captures:

3290+ 1: entity.name.label.tsx

3291+ 2: keyword.operator.optional.tsx

3292+ 3: punctuation.separator.label.tsx

29003293 - include: type

29013294 - include: punctuation-comma

29023295 typeof-operator:

29033296 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))typeof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

2904− scope: keyword.operator.expression.typeof.tsx

3297+ captures:

3298+ 0: keyword.operator.expression.typeof.tsx

3299+ push:

3300+ - match: '(?=[,);}\]=>:&|{\?]|$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'

3301+ pop: true

3302+ - include: expression

29053303 undefined-literal:

29063304 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))undefined(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

29073305 scope: constant.language.undefined.tsx

29083306 var-expr:

2909− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

2910− captures:

2911− 1: keyword.control.export.tsx

2912− 2: storage.type.tsx

3307+ - match: '(?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))'

29133308 push:

29143309 - meta_scope: meta.var.expr.tsx

2915− - match: '((?=;|}|(\s+(of|in)\s+)|^\s*$|;|^\s*abstract\b|^\s*async\b|^\s*class\b|^\s*const\b|^\s*declare\b|^\s*enum\b|^\s*export\b|^\s*function\b|^\s*import\b|^\s*interface\b|^\s*let\b|^\s*module\b|^\s*namespace\b|^\s*return\b|^\s*type\b|^\s*var\b)|((?<=\S)(?<!^let|[^\._$[:alnum:]]let|^var|[^\._$[:alnum:]]var)(?=\s*$)))'

3310+ - 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*$)))'

29163311 pop: true

3312+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*'

3313+ captures:

3314+ 1: keyword.control.export.tsx

3315+ 2: storage.modifier.tsx

3316+ 3: storage.type.tsx

3317+ push:

3318+ - match: (?=\S)

3319+ pop: true

29173320 - include: destructuring-variable

29183321 - include: var-single-variable

29193322 - include: variable-initializer

29203323 - include: comment

2921− - match: (,)\s*(?!\S)

3324+ - match: (,)\s*((?!\S)|(?=\/\/))

29223325 captures:

29233326 1: punctuation.separator.comma.tsx

29243327 push:

2925− - match: '(?<!,)(((?==|;|}|(\s+(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$)))'

3328+ - match: '(?<!,)(((?==|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$)))'

29263329 pop: true

3330+ - include: single-line-comment-consuming-line-ending

29273331 - include: comment

29283332 - include: destructuring-variable

29293333 - include: var-single-variable

29303334 - include: punctuation-comma

29313335 - include: punctuation-comma

2932− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

3336+ - match: '(?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))'

29333337 captures:

29343338 1: keyword.control.export.tsx

2935− 2: storage.type.tsx

3339+ 2: storage.modifier.tsx

3340+ 3: storage.type.tsx

29363341 push:

29373342 - meta_scope: meta.var.expr.tsx

2938− - match: '((?=;|}|(\s+(of|in)\s+)|^\s*$|;|^\s*abstract\b|^\s*async\b|^\s*class\b|^\s*const\b|^\s*declare\b|^\s*enum\b|^\s*export\b|^\s*function\b|^\s*import\b|^\s*interface\b|^\s*let\b|^\s*module\b|^\s*namespace\b|^\s*return\b|^\s*type\b|^\s*var\b)|((?<=\S)(?<!^const|[^\._$[:alnum:]]const)(?=\s*$)))'

3343+ - 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*$)))'

29393344 pop: true

3345+ - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*'

3346+ captures:

3347+ 1: keyword.control.export.tsx

3348+ 2: storage.modifier.tsx

3349+ 3: storage.type.tsx

3350+ push:

3351+ - match: (?=\S)

3352+ pop: true

29403353 - include: destructuring-const

29413354 - include: var-single-const

29423355 - include: variable-initializer

29433356 - include: comment

2944− - match: (,)\s*(?!\S)

3357+ - match: (,)\s*((?!\S)|(?=\/\/))

29453358 captures:

29463359 1: punctuation.separator.comma.tsx

29473360 push:

2948− - match: '(?<!,)(((?==|;|}|(\s+(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$)))'

3361+ - match: '(?<!,)(((?==|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$)))'

29493362 pop: true

3363+ - include: single-line-comment-consuming-line-ending

29503364 - include: comment

29513365 - include: destructuring-const

29523366 - include: var-single-const

@@ -2963,11 +3377,11 @@ contexts:

29633377 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

29643378 )) |

29653379 ((async\s*)?(

2966− ((<\s*$)|([\(]\s*([\{\[]\s*)?$)) |

3380+ ((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

29673381 # sure shot arrow functions even if => is on new line

29683382 (

2969− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

2970− [(]\s*

3383+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

3384+ [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

29713385 (

29723386 ([)]\s*:) | # ():

29733387 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

@@ -2978,9 +3392,9 @@ contexts:

29783392 ) |

29793393 # arrow function possible to detect only with => on same line

29803394 (

2981− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

2982− $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

2983− (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

3395+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

3396+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

3397+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

29843398 \s*=> # arrow operator

29853399 )

29863400 ))

@@ -2997,19 +3411,20 @@ contexts:

29973411 ))

29983412 ))

29993413 )) |

3000− (:\s*((<\s*$)|([\(]\s*([\{\[]\s*)?$))) |

3001− (:\s*(=>|($([^\($]|($[^\($]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

3414+ (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |

3415+ (:\s*((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

3416+ (:\s*(=>|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

30023417 ((async\s+)?(

30033418 (function\s*[(<*]) |

30043419 (function\s+) |

30053420 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

30063421 )) |

30073422 ((async\s*)?(

3008− ((<\s*$)|([\(]\s*([\{\[]\s*)?$)) |

3423+ ((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

30093424 # sure shot arrow functions even if => is on new line

30103425 (

3011− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

3012− [(]\s*

3426+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

3427+ [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

30133428 (

30143429 ([)]\s*:) | # ():

30153430 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

@@ -3020,9 +3435,9 @@ contexts:

30203435 ) |

30213436 # arrow function possible to detect only with => on same line

30223437 (

3023− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

3024− $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

3025− (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

3438+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

3439+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

3440+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

30263441 \s*=> # arrow operator

30273442 )

30283443 ))

@@ -3031,7 +3446,7 @@ contexts:

30313446 1: meta.definition.variable.tsx variable.other.constant.tsx entity.name.function.tsx

30323447 push:

30333448 - meta_scope: meta.var-single-variable.expr.tsx

3034− - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

3449+ - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'

30353450 pop: true

30363451 - include: var-single-variable-type-annotation

30373452 - match: "([_$[:alpha:]][_$[:alnum:]]*)"

@@ -3039,12 +3454,12 @@ contexts:

30393454 1: meta.definition.variable.tsx variable.other.constant.tsx

30403455 push:

30413456 - meta_scope: meta.var-single-variable.expr.tsx

3042− - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

3457+ - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'

30433458 pop: true

30443459 - include: var-single-variable-type-annotation

30453460 var-single-variable:

30463461 - match: |-

3047− (?x)([_$[:alpha:]][_$[:alnum:]]*)(?=\s*

3462+ (?x)([_$[:alpha:]][_$[:alnum:]]*)(\!)?(?=\s*

30483463 # function assignment |

30493464 (=\s*(

30503465 ((async\s+)?(

@@ -3053,11 +3468,11 @@ contexts:

30533468 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

30543469 )) |

30553470 ((async\s*)?(

3056− ((<\s*$)|([\(]\s*([\{\[]\s*)?$)) |

3471+ ((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

30573472 # sure shot arrow functions even if => is on new line

30583473 (

3059− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

3060− [(]\s*

3474+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

3475+ [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

30613476 (

30623477 ([)]\s*:) | # ():

30633478 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

@@ -3068,9 +3483,9 @@ contexts:

30683483 ) |

30693484 # arrow function possible to detect only with => on same line

30703485 (

3071− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

3072− $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

3073− (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

3486+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

3487+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

3488+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

30743489 \s*=> # arrow operator

30753490 )

30763491 ))

@@ -3087,19 +3502,20 @@ contexts:

30873502 ))

30883503 ))

30893504 )) |

3090− (:\s*((<\s*$)|([\(]\s*([\{\[]\s*)?$))) |

3091− (:\s*(=>|($([^\($]|($[^\($]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

3505+ (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |

3506+ (:\s*((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |

3507+ (:\s*(=>|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

30923508 ((async\s+)?(

30933509 (function\s*[(<*]) |

30943510 (function\s+) |

30953511 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

30963512 )) |

30973513 ((async\s*)?(

3098− ((<\s*$)|([\(]\s*([\{\[]\s*)?$)) |

3514+ ((<\s*$)|([$]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\($\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |

30993515 # sure shot arrow functions even if => is on new line

31003516 (

3101− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

3102− [(]\s*

3517+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?

3518+ [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*

31033519 (

31043520 ([)]\s*:) | # ():

31053521 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

@@ -3110,34 +3526,37 @@ contexts:

31103526 ) |

31113527 # arrow function possible to detect only with => on same line

31123528 (

3113− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

3114− $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

3115− (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

3529+ (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|($([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters

3530+ $\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\($]|($([^\($]|$[^\($]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters

3531+ (\s*:\s*([^<>\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|$[^\($]+\)|\{[^\{\}]+\})+)? # return type

31163532 \s*=> # arrow operator

31173533 )

31183534 ))

31193535 )))

31203536 captures:

31213537 1: meta.definition.variable.tsx entity.name.function.tsx

3538+ 2: keyword.operator.definiteassignment.tsx

31223539 push:

31233540 - meta_scope: meta.var-single-variable.expr.tsx

3124− - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

3541+ - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'

31253542 pop: true

31263543 - include: var-single-variable-type-annotation

3127− - match: "([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])"

3544+ - match: '([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])(\!)?'

31283545 captures:

31293546 1: meta.definition.variable.tsx variable.other.constant.tsx

3547+ 2: keyword.operator.definiteassignment.tsx

31303548 push:

31313549 - meta_scope: meta.var-single-variable.expr.tsx

3132− - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

3550+ - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'

31333551 pop: true

31343552 - include: var-single-variable-type-annotation

3135− - match: "([_$[:alpha:]][_$[:alnum:]]*)"

3553+ - match: '([_$[:alpha:]][_$[:alnum:]]*)(\!)?'

31363554 captures:

31373555 1: meta.definition.variable.tsx variable.other.readwrite.tsx

3556+ 2: keyword.operator.definiteassignment.tsx

31383557 push:

31393558 - meta_scope: meta.var-single-variable.expr.tsx

3140− - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

3559+ - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'

31413560 pop: true

31423561 - include: var-single-variable-type-annotation

31433562 var-single-variable-type-annotation:

@@ -3145,17 +3564,17 @@ contexts:

31453564 - include: string

31463565 - include: comment

31473566 variable-initializer:

3148− - match: (?<!=|!)(=)(?!=)(?=\s*\S)

3567+ - match: (?<!=|!)(=)(?!=)(?=\s*\S)(?!\s*.*=>\s*$)

31493568 captures:

31503569 1: keyword.operator.assignment.tsx

31513570 push:

3152− - match: '(?=$|^|[,);}\]])'

3571+ - match: '(?=$|^|[,);}\]]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'

31533572 pop: true

31543573 - include: expression

31553574 - match: (?<!=|!)(=)(?!=)

31563575 captures:

31573576 1: keyword.operator.assignment.tsx

31583577 push:

3159− - match: '(?=[,);}\]])|(?=^\s*$)|(?<=\S)(?<!=)(?=\s*$)'

3578+ - match: '(?=[,);}\]]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))|(?=^\s*$)|(?<=\S)(?<!=)(?=\s*$)'

31603579 pop: true

31613580 - include: expression

assets/syntaxes/02_Extra/VimL+1−1

Submodule changed.

assets/syntaxes/02_Extra/VimL.sublime-syntaxdeleted−91

@@ -1,91 +0,0 @@

1−%YAML 1.2

2−---

3−# http://www.sublimetext.com/docs/3/syntax.html

4−name: VimL

5−file_extensions:

6− - vim

7− - .vimrc

8−scope: source.viml

9−contexts:

10− main:

11− - include: comment

12− - include: string_quoted_double

13− - include: string_quoted_single

14− - include: string_regex

15− - include: inline_comment

16− - include: number_int

17− - include: number_hex

18− - include: keyword

19− - include: support_function

20− - include: support_variable

21− - include: support_type

22− - include: function_params

23− - include: function_definition

24− - include: function_call

25− - include: function

26− - include: variable

27− - include: expr

28− comment:

29− - match: ^\s*".*$

30− scope: comment.line.quotes.viml

31− captures:

32− 1: punctuation.definition.comment.vim

33− expr:

34− - match: (\|\||&&|==(\?|#)?|(!|>|<)=(#|\?)?|(=|!)~(#|\?)?|(>|<)(#|\?)is|isnot|\.|\*|\\|%)

35− scope: storage.function.viml

36− function:

38− scope: storage.function.viml

39− function_call:

40− - match: '(([sgbwtl]|)?:?[0-9a-zA-Z_#]+)(?=\()'

41− scope: support.function.any-method

42− function_definition:

43− - match: '^\s*(function)\s*!?\s+(?=(s:)?[0-9a-zA-Z_#]+\s*\()'

44− captures:

45− 1: storage.function.viml

46− push:

47− - meta_scope: meta.function.viml

48− - match: (\()

49− captures:

50− 1: punctuation.definition.parameters.begin.viml

51− pop: true

52− - match: "(s:)?[0-9a-zA-Z_#]+"

53− scope: entity.name.function.viml

54− function_params:

55− - match: '-\w+='

56− scope: support.type.viml

57− inline_comment:

58− - match: '(?!\$)(")(?!\{).*$\n?'

59− scope: comment.line.quotes.viml

60− captures:

61− 1: punctuation.definition.comment.vim

62− keyword:

63− - match: \b(if|while|for|try|return|throw|end(if|for|while|try)?|au(g|group)|else(if|)?|do|in|catch|finally|:)\b

64− scope: keyword.control.viml

65− number_hex:

66− - match: "0x[0-9a-f]+"

67− scope: constant.numeric.hex

68− number_int:

69− - match: '-?\d+'

70− scope: constant.numeric.integer

71− string_quoted_double:

72− - match: '"(\\\\|\\"|\n[^\S\n]*\\|[^\n"])*"'

73− scope: string.quoted.double.viml

74− string_quoted_single:

75− - match: '''(''''|\n[^\S\n]*\\|[^\n''])*'''

76− scope: string.quoted.single.viml

77− string_regex:

78− - match: '/(\\\\|\\/|\n[^\S\n]*\\|[^\n/])*/'

79− scope: string.regexp.viml

80− support_function:

82− scope: support.function.viml

83− support_type:

84− - match: <.*?>

85− scope: support.type.viml

86− support_variable:

88− scope: support.variable.viml

89− variable:

90− - match: '([sSgGbBwWlLaAvV]:|@|$|&(?!&))\w*'

91− scope: variable.other.viml

assets/syntaxes/02_Extra/Zignew file+1

Submodule changed.

assets/syntaxes/02_Extra/cmd-helpnew file+1

Submodule changed.

assets/syntaxes/02_Extra/gnuplotnew file+1

Submodule changed.

assets/syntaxes/02_Extra/gnuplot.sublime-syntaxnew file+182

@@ -0,0 +1,182 @@

1+%YAML 1.2

2+---

3+# http://www.sublimetext.com/docs/3/syntax.html

4+name: gnuplot

5+file_extensions:

6+ - gp

7+ - gpl

8+ - gnuplot

9+ - gnu

10+ - plot

11+ - plt

12+scope: source.gnuplot

13+contexts:

14+ main:

15+ - include: number

16+ - include: string_single

17+ - include: string_double

18+ - match: '\b(for)\b\s*(\[)'

19+ comment: |

20+ gnuplot iteration statement.

21+ There are two forms:

22+ numeric [n = 1:2{:inc}]

23+ string based [str in "x y z"]

24+ but both can also iterate over lists etc, so this is kept loose.

25+ captures:

26+ 1: keyword.other.iteration.gnuplot

27+ 2: punctuation.definition.range.begin.gnuplot

28+ push:

29+ - meta_scope: meta.structure.iteration.gnuplot

30+ - match: '\]'

31+ captures:

32+ 0: punctuation.definition.range.end.gnuplot

33+ pop: true

34+ - include: number

35+ - include: operator

36+ - include: string_double

37+ - include: string_single

38+ - match: ":"

39+ scope: punctuation.separator.range.gnuplot

40+ - match: '\b([a-zA-Z]\w*)\b\s*(=|in)'

41+ scope: variable-assignment.range.gnuplot

42+ - match: '(?i:[^\s(pi|e)\]])'

43+ scope: invalid.illegal.expected-range-separator.gnuplot

44+ - match: '\['

45+ comment: "gnuplot range statement [a:b]. Lots of things are legal, still more make no sense!"

46+ captures:

47+ 0: punctuation.definition.range.begin.gnuplot

48+ push:

49+ - meta_scope: meta.structure.range.gnuplot

50+ - match: '\]'

51+ captures:

52+ 0: punctuation.definition.range.end.gnuplot

53+ pop: true

54+ - include: number

55+ - include: operator

56+ - match: ":"

57+ scope: punctuation.separator.range.gnuplot

58+ - match: '(?i:[^\s(pi|e)\]])'

59+ scope: invalid.illegal.expected-range-separator.gnuplot

60+ - match: \\.

61+ scope: constant.character.escape.gnuplot

62+ - match: '(?<!\$)(#)(?!\{).*$\n?'

63+ scope: comment.line.number-sign.gnuplot

64+ captures:

65+ 1: punctuation.definition.comment.gnuplot

66+ - match: for

67+ comment: introduce in gnuplot 4.3.

68+ scope: keyword.other.iteration.gnuplot

70+ scope: keyword.other.setting.gnuplot

72+ comment: missuse of scopes alert! Just for pretty colours

73+ scope: keyword.other.command.gnuplot

75+ scope: support.function.gnuplot

77+ scope: support.function.string.gnuplot

79+ scope: constant.other.type.gnuplot

81+ scope: constant.other.terminal.gnuplot

83+ scope: keyword.modifier.gnuplot

84+ - match: |-

85+ (?x:

86+ \b # Start with a word boundary

87+ (?=\b[\w$]*(\(|.*=)) # Look-ahead for a bracket or equals

88+ (?![^(]*\)) # negative look ahead for a closing bracket without an opening one. This stops a from matching in f(a)

89+ ( # Group variable name

90+ [A-Za-z] # A letter

91+ [\w$]* # Any word chars or $

92+ ) # That is it for the name.

93+ )

94+ comment: user defined function / variable

95+ scope: variable.other.gnuplot

96+ - match: \b(if)\b

97+ scope: keyword.control.gnuplot

98+ - match: \b(show)\b

99+ captures:

100+ 0: keyword.other.command.gnuplot

101+ push:

102+ - meta_scope: keyword.line.show.gnuplot

103+ - meta_content_scope: keyword.line.show.gnuplot

104+ - match: (?!\#)($\n?)

105+ pop: true

106+ - include: main

107+ - match: \b(set)\b\s*\b(terminal|term)\b

108+ captures:

109+ 1: keyword.other.command.gnuplot

110+ 2: keyword.other.setting.gnuplot

111+ push:

112+ - meta_scope: keyword.line.set.terminal.gnuplot

113+ - match: (?!\#)($\n?)

114+ pop: true

115+ - include: main

116+ - match: \b(set)\b\s*\b(key)\b

117+ captures:

118+ 1: keyword.other.command.gnuplot

119+ 2: keyword.other.setting.gnuplot

120+ push:

121+ - meta_scope: keyword.line.set.key.gnuplot

122+ - match: (?!\#)($\n?)

123+ pop: true

124+ - include: main

125+ - match: \b(set|unset)\b\s*(?!\b(terminal|key|for)\b)

126+ captures:

127+ 1: keyword.other.command.gnuplot

128+ 2: keyword.other.setting.gnuplot

129+ push:

130+ - meta_scope: keyword.line.set.gnuplot

131+ - meta_content_scope: keyword.line.set.gnuplot

132+ - match: (?!\#)($\n?)

133+ pop: true

134+ - include: main

135+ number:

136+ - match: |-

137+ (?x: # turn on extended mode

138+ -? # an optional minus

139+ (?:

140+ 0 # a zero

141+ | # ...or...

142+ [1-9] # a 1-9 character

143+ \d* # followed by zero or more digits

144+ )

145+ (?:

146+ \. # a period

147+ \d+ # followed by one or more digits

148+ (?:

149+ [eE] # an e character

150+ [+-]? # followed by an option +/-

151+ \d+ # followed by one or more digits

152+ )? # make exponent optional

153+ )? # make decimal portion optional

154+ )

155+ comment: borrowed from textmate book

156+ scope: constant.numeric.gnuplot

157+ operator:

158+ - match: \s*(==|~=|>|>=|<|<=|&|&&|:|\||\|\||\+|-|\*|\.\*|/|\./|\\|\.\\|\^|\.\^)\s*

159+ comment: Operator symbols

160+ scope: keyword.operator.symbols.matlab

161+ string_double:

162+ - match: '"'

163+ captures:

164+ 0: punctuation.definition.string.begin.gnuplot

165+ push:

166+ - meta_scope: string.quoted.double.gnuplot

167+ - match: '"'

168+ captures:

169+ 0: punctuation.definition.string.end.gnuplot

170+ pop: true

171+ - match: '\\[\$`"\\\n]'

172+ scope: constant.character.escape.gnuplot

173+ string_single:

174+ - match: "'"

175+ captures:

176+ 0: punctuation.definition.string.begin.gnuplot

177+ push:

178+ - meta_scope: string.quoted.single.gnuplot

179+ - match: "'"

180+ captures:

181+ 0: punctuation.definition.string.end.gnuplot

182+ pop: true

assets/syntaxes/02_Extra/http-request-responsenew file+1

Submodule changed.

assets/syntaxes/02_Extra/log.sublime-syntaxnew file+140

@@ -0,0 +1,140 @@

1+%YAML 1.2

2+---

3+# See http://www.sublimetext.com/docs/3/syntax.html

4+file_extensions:

5+ - log

6+scope: text.log

7+variables:

8+ ipv4_part: (?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)

9+ hours_minutes_seconds: (?:[01]\d|2[0-3]):(?:[0-5]\d):(?:[0-5]\d)

10+contexts:

11+ main:

12+ - match: (\w+)(=)

13+ captures:

14+ 1: variable.parameter.log

15+ 2: keyword.operator.assignment.log

16+ - match: (')([^']*)(')

17+ scope: string.quoted.single.log

18+ captures:

19+ 1: punctuation.definition.string.begin.log

20+ 3: punctuation.definition.string.end.log

21+ - match: \"

22+ captures:

23+ 1: punctuation.definition.string.begin.log

24+ push: double_quoted_string

25+ - include: dates

26+ - include: ip_addresses

27+ - include: numbers

28+ - match: \b(?i:fail(?:ure|ed)?|error|exception)\b

29+ scope: markup.error.log

30+ - match: \b(?i:warn(?:ing)?)\b

31+ scope: markup.warning.log

32+ - match: \b(?i:debug)\b

33+ scope: markup.info.log

34+ #- include: scope:text.html.markdown#autolink-inet

35+ - match: \b\w+:/{2,3}

36+ scope: markup.underline.link.scheme.log

37+ push: url-host

38+ dates:

39+ - match: \b\d{4}-\d{2}-\d{2}(?=\b|T)

40+ scope: meta.date.log meta.number.integer.decimal.log constant.numeric.value.log

41+ push: maybe_date_time_separator

42+ - match: \b\d{4}/\d{2}/\d{2}(?=\b|T)

43+ scope: meta.date.log meta.number.integer.decimal.log constant.numeric.value.log

44+ push: maybe_date_time_separator

45+ - match: \b(?={{hours_minutes_seconds}})

46+ push: time

47+ time:

48+ - match: (?:{{hours_minutes_seconds}})(?:(\.)\d{3})?\b

49+ scope: meta.time.log meta.number.integer.decimal.log constant.numeric.value.log

50+ captures:

51+ 1: punctuation.separator.decimal.log

52+ - match: ''

53+ pop: true

54+ maybe_date_time_separator:

55+ - match: T(?={{hours_minutes_seconds}})

56+ scope: meta.date.log meta.time.log keyword.other.log

57+ set: time

58+ - match: ''

59+ pop: true

60+ ip_addresses:

61+ - match: \b(?=(?:{{ipv4_part}}\.){3}{{ipv4_part}}\b)

62+ push:

63+ - meta_scope: meta.ipaddress.v4.log meta.number.integer.decimal.log

64+ - match: \d+

65+ scope: constant.numeric.value.log

66+ - match: \.

67+ scope: punctuation.separator.sequence.log

68+ - match: ''

69+ pop: true

70+ - match: (?=(?:\h{0,4}:){2,6}\h{1,4}\b)

71+ push:

72+ - meta_scope: meta.ipaddress.v6.log meta.number.integer.hexadecimal.log

73+ - match: \h{1,4}

74+ scope: constant.numeric.value.log

75+ - match: ':'

76+ scope: punctuation.separator.sequence.log

77+ - match: ''

78+ pop: true

79+ numbers:

80+ - match: \b(0x)(\h+)(?:(\.)(\h+))?\b

81+ scope: meta.number.float.hexadecimal.log

82+ captures:

83+ 1: constant.numeric.base.log

84+ 2: constant.numeric.value.log

85+ 3: constant.numeric.value.log punctuation.separator.decimal.log

86+ 4: constant.numeric.value.log

87+ - match: \b\d+(\.)\d+\b

88+ scope: meta.number.float.log constant.numeric.value.log

89+ captures:

90+ 1: punctuation.separator.decimal.log

91+ - match: \b\d+\b

92+ scope: meta.number.integer.log constant.numeric.value.log

93+ url-host:

94+ - meta_content_scope: markup.underline.link.host.log

95+ - match: \[

96+ scope: punctuation.section.brackets.begin.log

97+ push:

98+ - match: \]

99+ scope: punctuation.section.brackets.end.log

100+ pop: true

101+ - include: ip_addresses

102+ - match: '[^:/\s]+'

103+ - match: ''

104+ set: url-after-host

105+ url-after-host:

106+ - match: (:)(\d+)

107+ scope: markup.underline.link.port.log

108+ captures:

109+ 1: punctuation.separator.mapping.port.log

110+ 2: constant.numeric.value.log

111+ #- include: scope:text.html.markdown#url-escaped-chars

112+ - match: (%)\h{2}

113+ scope: markup.underline.link.path.log constant.character.escape.url.log

114+ captures:

115+ 1: punctuation.definition.escape.log

116+ # After a valid domain, zero or more non-space non-< characters may follow

117+ - match: (?=[?!.,:*_~]*[\s<]) # Trailing punctuation (specifically, ?, !, ., ,, :, *, _, and ~) will not be considered part of the autolink, though they may be included in the interior of the link

118+ pop: true

119+ - match: \( # When an autolink ends in ), we scan the entire autolink for the total number of parentheses. If there is a greater number of closing parentheses than opening ones, we don’t consider the last character part of the autolink, in order to facilitate including an autolink inside a parenthesis

120+ push:

121+ - meta_scope: markup.underline.link.path.log

122+ - match: (?=[?!.,:*_~]*[\s<])

123+ pop: true

124+ - match: \)

125+ pop: true

126+ - match: (?=\)[?!.,:*_~]*[\s<])

127+ pop: true

128+ - match: '[^?!.,:*_~\s<&()%]+|\S'

129+ scope: markup.underline.link.path.log

130+ - match: ''

131+ pop: true

132+ double_quoted_string:

133+ - meta_scope: string.quoted.double.log

134+ - match: \\"

135+ scope: constant.character.escape.log

136+ - match: \\n

137+ scope: constant.character.escape.log

138+ - match: \"

139+ scope: punctuation.definition.string.end.log

140+ pop: true

assets/syntaxes/02_Extra/requirementstxtdeleted−1

Submodule changed.

assets/syntaxes/02_Extra/requirementstxt.sublime-syntaxdeleted−19

@@ -1,19 +0,0 @@

1−%YAML 1.2

2−---

3−# http://www.sublimetext.com/docs/3/syntax.html

4−name: requirements.txt

5−file_extensions:

6− - requirements.txt

7−scope: source.requirementstxt

8−contexts:

9− main:

10− - match: (#).*$\n?

11− scope: comment.line.requirementstxt

12− captures:

13− 1: punctuation.definition.comment.requirementstxt

14− - match: '(?i)^[a-z0-9_\-\.]+'

15− scope: string.package_name.requirementstxt

16− - match: (?i)==|<|<=|>=|>

17− scope: keyword.operator.logical.punctuation.requirementstxt

18− - match: '(?i)\d+\.[\da-z\-_\.]*'

19− scope: constant.numeric.verions.requirementstxt

assets/syntaxes/02_Extra/ssh-config+1−1

Submodule changed.

assets/syntaxes/02_Extra/syntax_test_csv.csvnew file+60

@@ -0,0 +1,60 @@

1+# SYNTAX TEST "CSV.sublime-syntax"

2+Forename,Surname,House No.,Street,City,Postcode

3+#^^^^^^^ meta.field-1

4+# ^ punctuation.separator.sequence

5+# ^^^^^^^ meta.field-2

6+# ^ punctuation.separator.sequence

7+# ^^^^^^^^^ meta.field-3

8+# ^ punctuation.separator.sequence

9+# ^^^^^^ meta.field-4

10+# ^ punctuation.separator.sequence

11+# ^^^^ meta.field-1

12+# ^ punctuation.separator.sequence

13+# ^^^^^^^^ meta.field-2

14+John,Doe,87,Logon Road,Citiville,TU43 6GH

15+#^^^ meta.field-1

16+# ^ punctuation.separator.sequence

17+# ^^^ meta.field-2

18+# ^ punctuation.separator.sequence

19+# ^^ meta.field-3

20+# ^ punctuation.separator.sequence

21+# ^^^^^^^^^^ meta.field-4

22+# ^ punctuation.separator.sequence

23+# ^^^^^^^^^ meta.field-1

24+# ^ punctuation.separator.sequence

25+# ^^^^^^^^ meta.field-2

26+Jane,Doe,22,"""Fun"" Street","The City, County",FA90 1XA

27+#^^^ meta.field-1

28+# ^ punctuation.separator.sequence

29+# ^^^ meta.field-2

30+# ^ punctuation.separator.sequence

31+# ^^ meta.field-3

32+# ^ punctuation.separator.sequence

33+# ^^^^^^^^^^^^^^^^ meta.field-4 string.quoted.double

34+# ^^ constant.character.escape

35+# ^^ constant.character.escape

36+# ^ punctuation.separator.sequence

37+# ^ meta.field-1 string.quoted.double punctuation.definition.string.begin

38+# ^^^^^^^^^^^^^^^^^ meta.field-1 string.quoted.double

39+# ^ meta.field-1 string.quoted.double punctuation.definition.string.end

40+# ^ punctuation.separator.sequence

41+# ^^^^^^^^ meta.field-2

42+Fred,Bloggs,"19","Street

43+#^^^ meta.field-1

44+# ^ punctuation.separator.sequence

45+# ^^^^^^ meta.field-2

46+# ^ punctuation.separator.sequence

47+# ^^^ meta.field-3 string.quoted.double

48+# ^ punctuation.separator.sequence

49+# ^ meta.field-4 punctuation.definition.string.begin

50+# ^^^^^^^^ meta.field-4 string.quoted.double

51+Spanning Multiple ""

52+#^^^^^^^^^^^^^^^^^^^^ meta.field-4 string.quoted.double

53+# ^^ constant.character.escape

54+Lines",Citee,P0stc0d3

55+#^^^^^ meta.field-4 string.quoted.double

56+# ^ meta.field-4 punctuation.definition.string.end

57+# ^ punctuation.separator.sequence

58+# ^^^^^ meta.field-1

59+# ^ punctuation.separator.sequence

60+# ^^^^^^^^ meta.field-2

assets/syntaxes/02_Extra/syntax_test_man.man+11

@@ -149,3 +149,14 @@ EXAMPLE

149149 #define POLLIN_SET (EPOLLRDNORM | EPOLLRDBAND | EPOLLIN |

150150 EPOLLHUP | EPOLLERR)

151151# ^ source.c meta.preprocessor.macro meta.group punctuation.section.group.end

152+

153+ENVIRONMENT

154+ $SYSTEMD_LOG_LEVEL

155+# ^ punctuation.definition.variable

156+# ^^^^^^^^^^^^^^^^^ constant.other

157+ systemd reads the log level from this environment variable. This

158+ can be overridden with --log-level=.

159+

160+SEE ALSO

161+ The systemd Homepage[11], systemd-system.conf(5), locale.conf(5)

162+# ^^^^^^^^^^^^^^^^^^^ entity.name.function

assets/syntaxes/02_Extra/syntax_test_tsv.tsvnew file+60

@@ -0,0 +1,60 @@

1+# SYNTAX TEST "CSV.sublime-syntax"

2+Forename Surname House No. Street City Postcode

3+#^^^^^^^ meta.field-1

4+# ^ punctuation.separator.sequence

5+# ^^^^^^^ meta.field-2

6+# ^ punctuation.separator.sequence

7+# ^^^^^^^^^ meta.field-3

8+# ^ punctuation.separator.sequence

9+# ^^^^^^ meta.field-4

10+# ^ punctuation.separator.sequence

11+# ^^^^ meta.field-1

12+# ^ punctuation.separator.sequence

13+# ^^^^^^^^ meta.field-2

14+John Doe 87 Logon Road Citiville TU43 6GH

15+#^^^ meta.field-1

16+# ^ punctuation.separator.sequence

17+# ^^^ meta.field-2

18+# ^ punctuation.separator.sequence

19+# ^^ meta.field-3

20+# ^ punctuation.separator.sequence

21+# ^^^^^^^^^^ meta.field-4

22+# ^ punctuation.separator.sequence

23+# ^^^^^^^^^ meta.field-1

24+# ^ punctuation.separator.sequence

25+# ^^^^^^^^ meta.field-2

26+Jane Doe 22 """Fun"" Street" "The City County" FA90 1XA

27+#^^^ meta.field-1

28+# ^ punctuation.separator.sequence

29+# ^^^ meta.field-2

30+# ^ punctuation.separator.sequence

31+# ^^ meta.field-3

32+# ^ punctuation.separator.sequence

33+# ^^^^^^^^^^^^^^^^ meta.field-4 string.quoted.double

34+# ^^ constant.character.escape

35+# ^^ constant.character.escape

36+# ^ punctuation.separator.sequence

37+# ^ meta.field-1 string.quoted.double punctuation.definition.string.begin

38+# ^^^^^^^^^^^^^^^^^ meta.field-1 string.quoted.double

39+# ^ meta.field-1 string.quoted.double punctuation.definition.string.end

40+# ^ punctuation.separator.sequence

41+# ^^^^^^^^ meta.field-2

42+Fred Bloggs "19" "Street

43+#^^^ meta.field-1

44+# ^ punctuation.separator.sequence

45+# ^^^^^^ meta.field-2

46+# ^ punctuation.separator.sequence

47+# ^^^ meta.field-3 string.quoted.double

48+# ^ punctuation.separator.sequence

49+# ^ meta.field-4 punctuation.definition.string.begin

50+# ^^^^^^^^ meta.field-4 string.quoted.double

51+Spanning Multiple ""

52+#^^^^^^^^^^^^^^^^^^^^ meta.field-4 string.quoted.double

53+# ^^ constant.character.escape

54+Lines" Citee P0stc0d3

55+#^^^^^ meta.field-4 string.quoted.double

56+# ^ meta.field-4 punctuation.definition.string.end

57+# ^ punctuation.separator.sequence

58+# ^^^^^ meta.field-1

59+# ^ punctuation.separator.sequence

60+# ^^^^^^^^ meta.field-2

assets/syntaxes/02_Extra/syslog.sublime-syntaxnew file+63

@@ -0,0 +1,63 @@

1+%YAML 1.2

2+---

3+# http://www.sublimetext.com/docs/3/syntax.html

4+name: syslog

5+file_extensions:

6+ - syslog

7+scope: text.log.syslog

8+contexts:

9+ main:

10+ - match: ^(\w+\s+\d+)\s+(\d{2}:\d{2}:\d{2})

11+ scope: meta.datetime.syslog constant.numeric.syslog

12+ captures:

13+ 1: meta.date.syslog

14+ 2: meta.time.syslog

15+ push: loghost

16+ - match: ^

17+ push: text

18+ loghost:

19+ - match: '[\w:.-]+'

20+ scope: entity.other.attribute-name.loghost.syslog

21+ set: process

22+ process:

23+ - match: ([\w.-]+)(?:(\[)(\d+)(\]))?([ :])

24+ captures:

25+ 1: support.function.process.syslog

26+ 2: punctuation.separator.pid.begin.syslog

27+ 3: meta.pid.syslog meta.number.integer.syslog constant.numeric.value.syslog

28+ 4: punctuation.separator.pid.end.syslog

29+ 5: punctuation.separator.mapping.syslog

30+ set: structured-data

31+ structured-data:

32+ - match: '\['

33+ scope: punctuation.section.mapping.begin.syslog

34+ push:

35+ - match: \]

36+ scope: punctuation.section.mapping.end.syslog

37+ pop: true

38+ - match: \w+

39+ scope: variable.parameter.syslog

40+ - match: =

41+ scope: keyword.operator.assignment.syslog

42+ push:

43+ - match: '[^\s\]]+'

44+ scope: constant.other.syslog

45+ pop: true

46+ - match: (?=\])

47+ pop: true

48+ - match: (?=\S)

49+ set: text

50+ text:

51+ - match: $

52+ pop: true

53+ - match: '<\w+>'

54+ scope: constant.language.syslog

55+ - match: \b(CMD)\b\s+(\()

56+ captures:

57+ 1: entity.name.label.syslog

58+ 2: punctuation.section.block.begin.syslog

59+ embed: scope:source.shell.bash

60+ escape: \)$

61+ escape_captures:

62+ 0: punctuation.section.block.end.syslog

63+ - include: scope:text.log

assets/themes.bin

Binary file not shown.

assets/themes/ansi-light.tmThemedeleted−504

@@ -1,504 +0,0 @@

1−<?xml version="1.0" encoding="UTF-8"?>

2−<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">

3−<plist version="1.0">

4− <dict>

5− <!--

6− The colors in this theme are encoded as #RRGGBBAA where RR is an ANSI

7− palette number from 00 to 0f, and AA is the special value 00 to indicate

8− that this encoding is being used.

9− -->

10− <key>author</key>

11− <string>Template: Chris Kempson, Scheme: Mitchell Kember</string>

12− <key>name</key>

13− <string>ANSI Light</string>

14− <key>colorSpaceName</key>

15− <string>sRGB</string>

16− <key>settings</key>

17− <array>

18− <dict>

19− <key>settings</key>

20− <dict>

21− <key>background</key>

22− <string>#07000000</string>

23− <key>caret</key>

24− <string>#00000000</string>

25− <key>foreground</key>

26− <string>#00000000</string>

27− <key>invisibles</key>

28− <string>#00000000</string>

29− <key>lineHighlight</key>

30− <string>#00000000</string>

31− <key>selection</key>

32− <string>#00000000</string>

33− <key>gutter</key>

34− <string>#07000000</string>

35− <key>gutterForeground</key>

36− <string>#00000000</string>

37− </dict>

38− </dict>

39− <dict>

40− <key>name</key>

41− <string>Text</string>

42− <key>scope</key>

43− <string>variable.parameter.function</string>

44− <key>settings</key>

45− <dict>

46− <key>foreground</key>

47− <string>#00000000</string>

48− </dict>

49− </dict>

50− <dict>

51− <key>name</key>

52− <string>Comments</string>

53− <key>scope</key>

54− <string>comment, punctuation.definition.comment</string>

55− <key>settings</key>

56− <dict>

57− <key>foreground</key>

58− <string>#02000000</string>

59− </dict>

60− </dict>

61− <dict>

62− <key>name</key>

63− <string>Punctuation</string>

64− <key>scope</key>

65− <string>punctuation.definition.string, punctuation.definition.variable, punctuation.definition.string, punctuation.definition.parameters, punctuation.definition.string, punctuation.definition.array</string>

66− <key>settings</key>

67− <dict>

68− <key>foreground</key>

69− <string>#00000000</string>

70− </dict>

71− </dict>

72− <dict>

73− <key>name</key>

74− <string>Delimiters</string>

75− <key>scope</key>

76− <string>none</string>

77− <key>settings</key>

78− <dict>

79− <key>foreground</key>

80− <string>#00000000</string>

81− </dict>

82− </dict>

83− <dict>

84− <key>name</key>

85− <string>Operators</string>

86− <key>scope</key>

87− <string>keyword.operator</string>

88− <key>settings</key>

89− <dict>

90− <key>foreground</key>

91− <string>#00000000</string>

92− </dict>

93− </dict>

94− <dict>

95− <key>name</key>

96− <string>Keywords</string>

97− <key>scope</key>

98− <string>keyword</string>

99− <key>settings</key>

100− <dict>

101− <key>foreground</key>

102− <string>#05000000</string>

103− </dict>

104− </dict>

105− <dict>

106− <key>name</key>

107− <string>Variables</string>

108− <key>scope</key>

109− <string>variable</string>

110− <key>settings</key>

111− <dict>

112− <key>foreground</key>

113− <string>#00000000</string>

114− </dict>

115− </dict>

116− <dict>

117− <key>name</key>

118− <string>Functions</string>

119− <key>scope</key>

120− <string>entity.name.function, meta.require, support.function.any-method</string>

121− <key>settings</key>

122− <dict>

123− <key>foreground</key>

124− <string>#04000000</string>

125− </dict>

126− </dict>

127− <dict>

128− <key>name</key>

129− <string>Labels</string>

130− <key>scope</key>

131− <string>entity.name.label</string>

132− <key>settings</key>

133− <dict>

134− <key>foreground</key>

135− <string>#06000000</string>

136− </dict>

137− </dict>

138− <dict>

139− <key>name</key>

140− <string>Classes</string>

141− <key>scope</key>

142− <string>support.class, entity.name.class, entity.name.type.class</string>

143− <key>settings</key>

144− <dict>

145− <key>foreground</key>

146− <string>#03000000</string>

147− </dict>

148− </dict>

149− <dict>

150− <key>name</key>

151− <string>Classes</string>

152− <key>scope</key>

153− <string>meta.class</string>

154− <key>settings</key>

155− <dict>

156− <key>foreground</key>

157− <string>#00000000</string>

158− </dict>

159− </dict>

160− <dict>

161− <key>name</key>

162− <string>Methods</string>

163− <key>scope</key>

164− <string>keyword.other.special-method</string>

165− <key>settings</key>

166− <dict>

167− <key>foreground</key>

168− <string>#04000000</string>

169− </dict>

170− </dict>

171− <dict>

172− <key>name</key>

173− <string>Storage</string>

174− <key>scope</key>

175− <string>storage</string>

176− <key>settings</key>

177− <dict>

178− <key>foreground</key>

179− <string>#05000000</string>

180− </dict>

181− </dict>

182− <dict>

183− <key>name</key>

184− <string>Support</string>

185− <key>scope</key>

186− <string>support.function</string>

187− <key>settings</key>

188− <dict>

189− <key>foreground</key>

190− <string>#06000000</string>

191− </dict>

192− </dict>

193− <dict>

194− <key>name</key>

195− <string>Strings, Inherited Class</string>

196− <key>scope</key>

197− <string>string, constant.other.symbol, entity.other.inherited-class</string>

198− <key>settings</key>

199− <dict>

200− <key>foreground</key>

201− <string>#02000000</string>

202− </dict>

203− </dict>

204− <dict>

205− <key>name</key>

206− <string>Integers</string>

207− <key>scope</key>

208− <string>constant.numeric</string>

209− <key>settings</key>

210− <dict>

211− <key>foreground</key>

212− <string>#03000000</string>

213− </dict>

214− </dict>

215− <dict>

216− <key>name</key>

217− <string>Floats</string>

218− <key>scope</key>

219− <string>none</string>

220− <key>settings</key>

221− <dict>

222− <key>foreground</key>

223− <string>#03000000</string>

224− </dict>

225− </dict>

226− <dict>

227− <key>name</key>

228− <string>Boolean</string>

229− <key>scope</key>

230− <string>none</string>

231− <key>settings</key>

232− <dict>

233− <key>foreground</key>

234− <string>#03000000</string>

235− </dict>

236− </dict>

237− <dict>

238− <key>name</key>

239− <string>Constants</string>

240− <key>scope</key>

241− <string>constant</string>

242− <key>settings</key>

243− <dict>

244− <key>foreground</key>

245− <string>#03000000</string>

246− </dict>

247− </dict>

248− <dict>

249− <key>name</key>

250− <string>Tags</string>

251− <key>scope</key>

252− <string>entity.name.tag</string>

253− <key>settings</key>

254− <dict>

255− <key>foreground</key>

256− <string>#01000000</string>

257− </dict>

258− </dict>

259− <dict>

260− <key>name</key>

261− <string>Attributes</string>

262− <key>scope</key>

263− <string>entity.other.attribute-name</string>

264− <key>settings</key>

265− <dict>

266− <key>foreground</key>

267− <string>#03000000</string>

268− </dict>

269− </dict>

270− <dict>

271− <key>name</key>

272− <string>Attribute IDs</string>

273− <key>scope</key>

274− <string>entity.other.attribute-name.id, punctuation.definition.entity</string>

275− <key>settings</key>

276− <dict>

277− <key>foreground</key>

278− <string>#04000000</string>

279− </dict>

280− </dict>

281− <dict>

282− <key>name</key>

283− <string>Selector</string>

284− <key>scope</key>

285− <string>meta.selector</string>

286− <key>settings</key>

287− <dict>

288− <key>foreground</key>

289− <string>#05000000</string>

290− </dict>

291− </dict>

292− <dict>

293− <key>name</key>

294− <string>Values</string>

295− <key>scope</key>

296− <string>none</string>

297− <key>settings</key>

298− <dict>

299− <key>foreground</key>

300− <string>#03000000</string>

301− </dict>

302− </dict>

303− <dict>

304− <key>name</key>

305− <string>Headings</string>

306− <key>scope</key>

307− <string>markup.heading punctuation.definition.heading, entity.name.section</string>

308− <key>settings</key>

309− <dict>

310− <key>fontStyle</key>

311− <string></string>

312− <key>foreground</key>

313− <string>#04000000</string>

314− </dict>

315− </dict>

316− <dict>

317− <key>name</key>

318− <string>Units</string>

319− <key>scope</key>

320− <string>keyword.other.unit</string>

321− <key>settings</key>

322− <dict>

323− <key>foreground</key>

324− <string>#03000000</string>

325− </dict>

326− </dict>

327− <dict>

328− <key>name</key>

329− <string>Bold</string>

330− <key>scope</key>

331− <string>markup.bold, punctuation.definition.bold</string>

332− <key>settings</key>

333− <dict>

334− <key>fontStyle</key>

335− <string>bold</string>

336− <key>foreground</key>

337− <string>#03000000</string>

338− </dict>

339− </dict>

340− <dict>

341− <key>name</key>

342− <string>Italic</string>

343− <key>scope</key>

344− <string>markup.italic, punctuation.definition.italic</string>

345− <key>settings</key>

346− <dict>

347− <key>fontStyle</key>

348− <string>italic</string>

349− <key>foreground</key>

350− <string>#05000000</string>

351− </dict>

352− </dict>

353− <dict>

354− <key>name</key>

355− <string>Code</string>

356− <key>scope</key>

357− <string>markup.raw.inline</string>

358− <key>settings</key>

359− <dict>

360− <key>foreground</key>

361− <string>#02000000</string>

362− </dict>

363− </dict>

364− <dict>

365− <key>name</key>

366− <string>Link Text</string>

367− <key>scope</key>

368− <string>string.other.link, punctuation.definition.string.end.markdown, punctuation.definition.string.begin.markdown</string>

369− <key>settings</key>

370− <dict>

371− <key>foreground</key>

372− <string>#01000000</string>

373− </dict>

374− </dict>

375− <dict>

376− <key>name</key>

377− <string>Link Url</string>

378− <key>scope</key>

379− <string>meta.link</string>

380− <key>settings</key>

381− <dict>

382− <key>foreground</key>

383− <string>#03000000</string>

384− </dict>

385− </dict>

386− <dict>

387− <key>name</key>

388− <string>Quotes</string>

389− <key>scope</key>

390− <string>markup.quote</string>

391− <key>settings</key>

392− <dict>

393− <key>foreground</key>

394− <string>#03000000</string>

395− </dict>

396− </dict>

397− <dict>

398− <key>name</key>

399− <string>Inserted</string>

400− <key>scope</key>

401− <string>markup.inserted</string>

402− <key>settings</key>

403− <dict>

404− <key>foreground</key>

405− <string>#02000000</string>

406− </dict>

407− </dict>

408− <dict>

409− <key>name</key>

410− <string>Deleted</string>

411− <key>scope</key>

412− <string>markup.deleted</string>

413− <key>settings</key>

414− <dict>

415− <key>foreground</key>

416− <string>#01000000</string>

417− </dict>

418− </dict>

419− <dict>

420− <key>name</key>

421− <string>Changed</string>

422− <key>scope</key>

423− <string>markup.changed</string>

424− <key>settings</key>

425− <dict>

426− <key>foreground</key>

427− <string>#05000000</string>

428− </dict>

429− </dict>

430− <dict>

431− <key>name</key>

432− <string>Colors</string>

433− <key>scope</key>

434− <string>constant.other.color</string>

435− <key>settings</key>

436− <dict>

437− <key>foreground</key>

438− <string>#06000000</string>

439− </dict>

440− </dict>

441− <dict>

442− <key>name</key>

443− <string>Regular Expressions</string>

444− <key>scope</key>

445− <string>string.regexp</string>

446− <key>settings</key>

447− <dict>

448− <key>foreground</key>

449− <string>#06000000</string>

450− </dict>

451− </dict>

452− <dict>

453− <key>name</key>

454− <string>Escape Characters</string>

455− <key>scope</key>

456− <string>constant.character.escape</string>

457− <key>settings</key>

458− <dict>

459− <key>foreground</key>

460− <string>#06000000</string>

461− </dict>

462− </dict>

463− <dict>

464− <key>name</key>

465− <string>Embedded</string>

466− <key>scope</key>

467− <string>punctuation.section.embedded, variable.interpolation</string>

468− <key>settings</key>

469− <dict>

470− <key>foreground</key>

471− <string>#05000000</string>

472− </dict>

473− </dict>

474− <dict>

475− <key>name</key>

476− <string>Illegal</string>

477− <key>scope</key>

478− <string>invalid.illegal</string>

479− <key>settings</key>

480− <dict>

481− <key>background</key>

482− <string>#01000000</string>

483− <key>foreground</key>

484− <string>#00000000</string>

485− </dict>

486− </dict>

487− <dict>

488− <key>name</key>

489− <string>Broken</string>

490− <key>scope</key>

491− <string>invalid.broken</string>

492− <key>settings</key>

493− <dict>

494− <key>background</key>

495− <string>#03000000</string>

496− <key>foreground</key>

497− <string>#07000000</string>

498− </dict>

499− </dict>

500− </array>

501− <key>uuid</key>

502− <string>uuid</string>

503− </dict>

504−</plist>

assets/themes/ansi-dark.tmTheme → assets/themes/ansi.tmThemerenamed+13−87

@@ -3,14 +3,14 @@

33<plist version="1.0">

44 <dict>

55 <!--

6− The colors in this theme are encoded as #RRGGBBAA where RR is an ANSI

7− palette number from 00 to 0f, and AA is the special value 00 to indicate

8− that this encoding is being used.

6+ The colors in this theme are encoded as #RRGGBBAA where:

7+ * If AA is 00, then RR is an ANSI palette number from 00 to 07.

8+ * If AA is 01, the terminal's default fg/bg color is used.

99 -->

1010 <key>author</key>

1111 <string>Template: Chris Kempson, Scheme: Mitchell Kember</string>

1212 <key>name</key>

13− <string>ANSI Dark</string>

13+ <string>ANSI</string>

1414 <key>colorSpaceName</key>

1515 <string>sRGB</string>

1616 <key>settings</key>

@@ -19,32 +19,17 @@

1919 <key>settings</key>

2020 <dict>

2121 <key>background</key>

22− <string>#00000000</string>

23− <key>caret</key>

24− <string>#07000000</string>

25− <key>foreground</key>

26− <string>#07000000</string>

27− <key>invisibles</key>

28− <string>#07000000</string>

29− <key>lineHighlight</key>

30− <string>#07000000</string>

31− <key>selection</key>

32− <string>#07000000</string>

22+ <string>#00000001</string>

23+ <key>foreground</key>

24+ <string>#00000001</string>

25+ <!--

26+ Explicitly set the gutter color since bat falls back to a

27+ hardcoded DEFAULT_GUTTER_COLOR otherwise.

28+ -->

3329 <key>gutter</key>

34− <string>#00000000</string>

30+ <string>#00000001</string>

3531 <key>gutterForeground</key>

36− <string>#07000000</string>

37− </dict>

38− </dict>

39− <dict>

40− <key>name</key>

41− <string>Text</string>

42− <key>scope</key>

43− <string>variable.parameter.function</string>

44− <key>settings</key>

45− <dict>

46− <key>foreground</key>

47− <string>#07000000</string>

32+ <string>#00000001</string>

4833 </dict>

4934 </dict>

5035 <dict>

@@ -58,39 +43,6 @@

5843 <string>#02000000</string>

5944 </dict>

6045 </dict>

61− <dict>

62− <key>name</key>

63− <string>Punctuation</string>

64− <key>scope</key>

66− <key>settings</key>

67− <dict>

68− <key>foreground</key>

69− <string>#07000000</string>

70− </dict>

71− </dict>

72− <dict>

73− <key>name</key>

74− <string>Delimiters</string>

75− <key>scope</key>

76− <string>none</string>

77− <key>settings</key>

78− <dict>

79− <key>foreground</key>

80− <string>#07000000</string>

81− </dict>

82− </dict>

83− <dict>

84− <key>name</key>

85− <string>Operators</string>

86− <key>scope</key>

87− <string>keyword.operator</string>

88− <key>settings</key>

89− <dict>

90− <key>foreground</key>

91− <string>#07000000</string>

92− </dict>

93− </dict>

9446 <dict>

9547 <key>name</key>

9648 <string>Keywords</string>

@@ -102,17 +54,6 @@

10254 <string>#05000000</string>

10355 </dict>

10456 </dict>

105− <dict>

106− <key>name</key>

107− <string>Variables</string>

108− <key>scope</key>

109− <string>variable</string>

110− <key>settings</key>

111− <dict>

112− <key>foreground</key>

113− <string>#07000000</string>

114− </dict>

115− </dict>

11657 <dict>

11758 <key>name</key>

11859 <string>Functions</string>

@@ -146,17 +87,6 @@

14687 <string>#03000000</string>

14788 </dict>

14889 </dict>

149− <dict>

150− <key>name</key>

151− <string>Classes</string>

152− <key>scope</key>

153− <string>meta.class</string>

154− <key>settings</key>

155− <dict>

156− <key>foreground</key>

157− <string>#07000000</string>

158− </dict>

159− </dict>

16090 <dict>

16191 <key>name</key>

16292 <string>Methods</string>

@@ -480,8 +410,6 @@

480410 <dict>

481411 <key>background</key>

482412 <string>#01000000</string>

483− <key>foreground</key>

484− <string>#07000000</string>

485413 </dict>

486414 </dict>

487415 <dict>

@@ -493,8 +421,6 @@

493421 <dict>

494422 <key>background</key>

495423 <string>#03000000</string>

496− <key>foreground</key>

497− <string>#00000000</string>

498424 </dict>

499425 </dict>

500426 </array>

assets/themes/dracula-sublime+1−1

Submodule changed.

assets/themes/gruvbox+1−1

Submodule changed.

assets/themes/onehalf+1−1

Submodule changed.

assets/themes/visual-studio-dark-plusnew file+1

Submodule changed.

assets/themes/zenburn+1−1

Submodule changed.

build.rs+10

@@ -54,11 +54,21 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {

5454 "assets/manual/bat.1.in",

5555 out_dir.join("assets/manual/bat.1"),

5656 )?;

57+ template(

58+ &variables,

59+ "assets/completions/bat.bash.in",

60+ out_dir.join("assets/completions/bat.bash"),

61+ )?;

5762 template(

5863 &variables,

5964 "assets/completions/bat.fish.in",

6065 out_dir.join("assets/completions/bat.fish"),

6166 )?;

67+ template(

68+ &variables,

69+ "assets/completions/_bat.ps1.in",

70+ out_dir.join("assets/completions/_bat.ps1"),

71+ )?;

6272 template(

6373 &variables,

6474 "assets/completions/bat.zsh.in",

diagnostics/info.sh+6−4

@@ -58,7 +58,8 @@ _bat_:run() {

5858 _out "$BAT" --version

5959 _out env | grep '^BAT_\|^PAGER='

6060

61− local cache_dir="$($BAT --cache-dir)"

61+ local cache_dir

62+ cache_dir="$($BAT --cache-dir)"

6263 if [[ -f "${cache_dir}/syntaxes.bin" ]]; then

6364 _print_command "$BAT" "--list-languages"

6465 echo "Found custom syntax set."

@@ -79,8 +80,8 @@ _bat_config_:run() {

7980_bat_wrapper_:run() {

8081 _bat_wrapper_:detect_wrapper() {

8182 local bat="$1"

82− if file "$(which "${bat}")" | grep "text executable" &> /dev/null; then

83− _out_fence cat "$(which "${bat}")"

83+ if file "$(command -v "${bat}")" | grep "text executable" &> /dev/null; then

84+ _out_fence cat "$(command -v "${bat}")"

8485 return

8586 fi

8687

@@ -104,7 +105,8 @@ _bat_wrapper_function_:run() {

104105 fi ;;

105106

106107 *bash* | *zsh*)

107− local type="$("$SHELL" --login -i -c "type ${command}" 2>&1)"

108+ local type

109+ type="$("$SHELL" --login -i -c "type ${command}" 2>&1)"

108110 if grep 'function' <<< "$type" &> /dev/null; then

109111 _out_fence "$SHELL" --login -i -c "declare -f ${command}"

110112 return

doc/README-ja.md+24−10

@@ -1,7 +1,6 @@

11

22 <img src="logo-header.svg" alt="bat - a cat clone with wings">

3− <a href="https://travis-ci.org/sharkdp/bat"><img src="https://travis-ci.org/sharkdp/bat.svg?branch=master" alt="Build Status"></a>

4− <a href="https://ci.appveyor.com/project/sharkdp/bat"><img src="https://ci.appveyor.com/api/projects/status/cptsmtbiwbnr2vhf?svg=true"></a>

3+ <a href="https://github.com/sharkdp/bat/actions?query=workflow%3ACICD"><img src="https://github.com/sharkdp/bat/workflows/CICD/badge.svg" alt="Build Status"></a>

54 <img src="https://img.shields.io/crates/l/bat.svg" alt="license">

65 <a href="https://crates.io/crates/bat"><img src="https://img.shields.io/crates/v/bat.svg?colorB=319e8c" alt="Version info"></a>

76 シンタックスハイライトとGitとの連携機能付きの cat(1) クローン。

@@ -12,8 +11,12 @@

1211 <a href="#使い方">使い方</a> •

1312 <a href="#インストール">インストール</a> •

1413 <a href="#カスタマイズ">カスタマイズ</a> •

15− <a href="#プロジェクトの目標と既存の類似したOSS">プロジェクトの目標と既存の類似したOSS</a> •

16− 翻訳 [<a href="https://github.com/chinanf-boy/bat-zh">中文</a>][<a href="README-ja.md">日本語</a>][<a href="README-ko.md">한국어</a>]

14+ <a href="#プロジェクトの目標と既存の類似したOSS">プロジェクトの目標と既存の類似したOSS</a>

15+ [<a href="../README.md">English</a>]

16+ [<a href="README-zh.md">中文</a>]

17+ [日本語]

18+ [<a href="README-ko.md">한국어</a>]

19+ [<a href="README-ru.md">Русский</a>]

1720

1821

1922### シンタックスハイライト

@@ -95,6 +98,17 @@ bat f - g # output 'f', then stdin, then 'g'.

9598

9699### 他のツールとの統合

97100

101+#### `fzf`

102+

103+[`fzf`](https://github.com/junegunn/fzf) のプレビューウィンドウに `bat` を使用できます。

104+その場合、`bat` の `--color=always` オプションを用いてカラー出力を強制しなければなりません。

105+また、`--line-range` オプションを用いることで巨大なファイルの読み込み時間を制限できます:

106+```bash

107+fzf --preview 'bat --color=always --style=numbers --line-range=:500 {}'

108+```

109+

110+詳しくは [`fzf` の `README`](https://github.com/junegunn/fzf#preview-window) を参照してください。

111+

98112#### `find` or `fd`

99113

100114`find` の `-exec` オプションを使用して、`bat` ですべての検索結果をプレビューできます:

@@ -167,7 +181,7 @@ man 2 select

167181

168182## インストール

169183

170−[![Packaging status](https://repology.org/badge/vertical-allrepos/bat.svg)](https://repology.org/project/bat/versions)

184+[![Packaging status](https://repology.org/badge/vertical-allrepos/bat-cat.svg)](https://repology.org/project/bat-cat/versions)

171185

172186### On Ubuntu (`apt` を使用)

173187*... や他のDebianベースのLinuxディストリビューション*

@@ -191,7 +205,7 @@ ln -s /usr/bin/batcat ~/.local/bin/bat

191205batの最新リリースを実行する場合、または Ubuntu/Debian の古いバージョンを使用している場合は、[release page](https://github.com/sharkdp/bat/releases) から最新の `.deb` パッケージをダウンロードし、

192206次の方法でインストールします:

193207```bash

194−sudo dpkg -i bat_0.17.1_amd64.deb # adapt version number and architecture

208+sudo dpkg -i bat_0.18.3_amd64.deb # adapt version number and architecture

195209```

196210

197211### On Alpine Linux

@@ -352,7 +366,7 @@ ansible-galaxy install aeimer.install_bat

352366### From source

353367

354368

355−`bat` をソースからビルドしたいならば、Rust 1.36 以上の環境が必要です。

369+`bat` をソースからビルドしたいならば、Rust 1.51 以上の環境が必要です。

356370`cargo` を使用してビルドすることができます:

357371

358372```bash

@@ -393,7 +407,7 @@ bat --list-themes | fzf --preview="bat --theme={} --color=always /path/to/file"

393407

394408### 新しい構文の追加 / 言語の定義

395409

396−`bat` はシンタックスハイライトのための [`syntext`](https://github.com/trishume/syntect/)

410+`bat` はシンタックスハイライトのための [`syntect`](https://github.com/trishume/syntect/)

397411という素晴らしいライブラリを使用しています。`syntect` は、

398412[Sublime Text の `.sublime-syntax` ファイル](https://www.sublimetext.com/docs/3/syntax.html)

399413とテーマを読み取ることができます。新しい構文を定義するために以下の手順を行います。

@@ -511,7 +525,7 @@ export BAT_CONFIG_PATH="/path/to/bat.conf"

511525# Use italic text on the terminal (not supported on all terminals)

512526--italic-text=always

513527

514−# Use C++ syntax for .ino files

528+# Use C++ syntax for Arduino .ino files

515529--map-syntax "*.ino:C++"

516530

517531# Use ".gitignore"-style highlighting for ".ignore" files

@@ -630,7 +644,7 @@ cargo install --locked --force

630644比較については [このドキュメント](alternatives.md) を参照してください。

631645

632646## ライセンス

634648

635649`bat` は MIT License 及び Apache License 2.0 の両方の条件の下で配布されています。

636650

doc/README-ko.md+466−191

@@ -1,75 +1,90 @@

11

2− <img src="../doc/logo-header.svg" alt="bat - a cat clone with wings">

3− <a href="https://travis-ci.org/sharkdp/bat"><img src="https://travis-ci.org/sharkdp/bat.svg?branch=master" alt="Build Status"></a>

4− <a href="https://ci.appveyor.com/project/sharkdp/bat"><img src="https://ci.appveyor.com/api/projects/status/cptsmtbiwbnr2vhf/branch/master?svg=true"></a>

2+ <img src="logo-header.svg" alt="bat - a cat clone with wings">

3+ <a href="https://github.com/sharkdp/bat/actions?query=workflow%3ACICD"><img src="https://github.com/sharkdp/bat/workflows/CICD/badge.svg" alt="Build Status"></a>

54 <img src="https://img.shields.io/crates/l/bat.svg" alt="license">

65 <a href="https://crates.io/crates/bat"><img src="https://img.shields.io/crates/v/bat.svg?colorB=319e8c" alt="Version info"></a>

7−

8− 문법 강조와 깃 통합 기능의 cat(1) 클론

6+ 문법 강조와 Git 통합 기능의 cat(1) 클론

97

108

119

1210 <a href="#문법-강조">주요 기능들</a> •

1311 <a href="#사용법">사용법</a> •

1412 <a href="#설치">설치</a> •

15− <a href="#커스터마이즈">커스터마이즈</a> •

16− <a href="#프로젝트-목표와-대안들">프로젝트 목표와 대안들</a> •

17− 번역 [<a href="https://github.com/chinanf-boy/bat-zh">中文</a>][<a href="../doc/README-ja.md">日本語</a>]

13+ <a href="#사용자화">사용자화</a> •

14+ <a href="#프로젝트-목표와-대안들">프로젝트 목표와 대안들</a>

15+ [<a href="../README.md">English</a>]

16+ [<a href="README-zh.md">中文</a>]

17+ [<a href="README-ja.md">日本語</a>]

18+ [한국어]

19+ [<a href="README-ru.md">Русский</a>]

1820

1921

2022### 문법 강조

2123

22−`bat`은 다양한 프로그래밍 언어와 마크업 언어에 대해 문법 강조(Syntax highlighting)기능을 지원하고 있습니다:

24+`bat`은 다양한 프로그래밍 및 마크업 언어의 문법 강조(syntax highlighting) 기능을

25+지원합니다:

2326

2427![Syntax highlighting example](https://imgur.com/rGsdnDe.png)

2528

2629### Git 통합

2730

28−`bat`은 `git`을 통해 인덱스와 함께 변경분을 표시합니다 (왼쪽 바를 확인하세요):

31+`bat`은 `git`을 통해 인덱스와 함께 변경분을 표시합니다

32+(왼쪽 사이드바를 확인하세요):

2933

3034![Git integration example](https://i.imgur.com/2lSW4RE.png)

3135

32−### 표시할 수 없는 문자 처리

36+### 비인쇄 문자 처리

3337

34−`-A`/`--show-all` 옵션을 사용하여 표시할수 없는 문자를 시각화 해줍니다:

38+`-A`/`--show-all` 옵션을 사용하여 비인쇄 문자를 표시 및 강조할 수 있습니다:

3539

3640![Non-printable character example](https://i.imgur.com/WndGp9H.png)

3741

38−### 자동 페이징

42+### 자동 페이징

3943

40−하나의 화면에 비해 출력이 너무 큰 경우, `less` 를 이용해 출력들을 연결할 수 있습니다.

44+`bat`은 기본적으로 한 화면에 비해 출력이 큰 경우 `less`와 같은 페이저(pager)로

45+출력을 연결(pipe)합니다.

46+만약 `bat`을 언제나 `cat`처럼 작동하게 하려면 (출력을 페이지하지 않기),

47+`--paging=never` 옵션을 커맨드 라인이나 설정 파일에 넣을 수 있습니다.

48+셸(shell) 설정에서 `cat`을 `bat`의 alias로 사용하려면,

49+`alias cat='bat --paging=never'`를 써서 기본 행동을 유지할 수 있습니다.

4150

42−### 파일 연결

51+### 파일 연결(concatenation)

4352

44−이 뿐만 아니라 파일을 연결할 때도 사용 할 수 있습니다. :wink: `bat`가 인터렉티브 하지 않은(non-interactive)가 감지하면 (예를 들어,다른 프로세스 혹은 파일과 파이프라인을 연결 한 경우) `bat`은 `cat`을 대신하여 동작하며 일반 파일 내용을 표기해줍니다.

53+페이저(pager)를 사용하더라도 `bat`은 파일들을 연결(concatenate)할 수 있습니다

54+:wink:.

55+`bat`이 비대화형(non-interactive) 터미널(예를 들어, 다른 프로세스나 파일에

56+연결(pipe)한 경우)을 감지하면, `bat`은 `--pager` 옵션의 값과 상관없이 `cat`과

57+동일하게 파일 내용을 그대로 출력합니다.

4558

4659## 사용법

4760

48−터미널에서 하나의 파일 표시하기

61+터미널에 하나의 파일 표시하기

4962

5063```bash

5164> bat README.md

5265```

5366

54−여러 파일 한번에 보여주기

67+여러 파일 한 번에 보여주기

5568

5669```bash

5770> bat src/*.rs

5871```

5972

60−stdin에서 읽고, 자동으로 맞는 문법 강조 적용하기

73+stdin에서 읽고, 자동으로 맞는 문법 결정하기 (참고로, 문법 강조는 파일의 첫

74+줄만으로 문법이 결정될 수 있을 때만 작동합니다.

75+이는 보통 `#!/bin/sh`와 같은 셔뱅(shebang)으로 판단합니다.)

6176

6277```bash

6378> curl -s https://sh.rustup.rs | bat

6479```

6580

66−stdin에서 읽고, 명시적으로 언어 지정하여 적용하기

81+stdin에서 읽고, 명시적으로 언어 지정하기

6782

6883```bash

6984> yaml2json .travis.yml | json_pp | bat -l json

7085```

7186

72−표시할 수 없는 문자 처리하기

87+비인쇄 문자 표시 및 강조하기

7388```bash

7489> bat -A /etc/hosts

7590```

@@ -86,23 +101,38 @@ bat -n main.rs # show line numbers (only)

86101bat f - g # output 'f', then stdin, then 'g'.

87102```

88103

89−### 다른 툴과의 통합

104+### 다른 도구들과 통합하기

105+

106+#### `fzf`

107+

108+`bat`을 [`fzf`](https://github.com/junegunn/fzf)의 프리뷰로 쓸 수 있습니다.

109+이를 위해서는 `bat`의 `--color=always` 옵션으로 항상 컬러 출력이 나오게 해야

110+합니다.

111+또한 `--line-range` 옵션으로 긴 파일의 로드 시간을 제한할 수 있습니다:

112+```bash

113+fzf --preview 'bat --color=always --style=numbers --line-range=:500 {}'

114+```

115+더 많은 정보는

116+[`fzf`의 `README`](https://github.com/junegunn/fzf#preview-window)를 참고하세요.

90117

91−#### `find` 와 `fd`

118+#### `find`와 `fd`

92119

93−`find`의 `-exec` 옵션을 사용하여 `bat`의 모든 검색 결과를 미리 볼 수 있습니다:

120+`find`의 `-exec` 옵션을 사용하여 모든 검색 결과를 `bat`로 미리 볼 수 있습니다:

94121```bash

95122find … -exec bat {} +

96123```

97124

98−[`fd`](https://github.com/sharkdp/fd)를 사용하고 있는 경우, `-X`/`--exec-batch` 옵션을 이용하여 동일하게 사용할 수 있습니다:

125+[`fd`](https://github.com/sharkdp/fd)를 사용하는 경우, `-X`/`--exec-batch`

126+옵션을 이용하여 동일하게 사용할 수 있습니다:

99127```bash

100128fd … -X bat

101129```

102130

103131#### `ripgrep`

104132

105−[`batgrep`](https://github.com/eth-p/bat-extras/blob/master/doc/batgrep.md)과 함께, [`ripgrep`](https://github.com/BurntSushi/ripgrep)의 검색 결과를 `bat`을 이용하여 볼 수 있습니다.

133+[`batgrep`](https://github.com/eth-p/bat-extras/blob/master/doc/batgrep.md)을

134+통해 `bat`로 [`ripgrep`](https://github.com/BurntSushi/ripgrep)의 검색 결과를

135+출력할 수 있습니다.

106136

107137```bash

108138batgrep needle src/

@@ -110,279 +140,401 @@ batgrep needle src/

110140

111141#### `tail -f`

112142

113−`bat` 과 `tail -f`를 함께 사용하여, 특정 파일을 문법 강조하며 지속적으로 모니터링 할 수 있습니다.

143+`bat`와 `tail -f`를 함께 사용하여 주어진 파일을 문법 강조하며 지속적으로

144+모니터할 수 있습니다.

114145```bash

115146tail -f /var/log/pacman.log | bat --paging=never -l log

116147```

117−이 작업을 하려면 페이징 기능을 꺼야합니다. 또, 자동 감지가 되지 않기 때문에, 적용되어야할 문법을 명시적(`-l log`)으로 지정해야 합니다.

148+참고로 이 작업을 하려면 페이징 기능을 꺼야 합니다.

149+또한 이 경우 문법을 자동 감지할 수 없기 때문에, 적용할 문법을 직접 지정해야

150+합니다 (`-l log`).

118151

119152#### `git`

120153

121−`bat`과 `git show`를 함께 사용하여 주어진 파일의 이전 기록을 문법 강조와 함께 볼 수 있습니다:

154+`bat`과 `git show`를 함께 사용하여 주어진 파일의 이전 버전을 올바른 문법 강조로

155+볼 수 있습니다:

122156```bash

123157git show v0.6.0:src/main.rs | bat -l rs

124158```

125159

126−diffs 내에서 문법 강조 표시는 현재 지원되지 않습니다. 이 기능은 [`delta`](https://github.com/dandavison/delta)에서 찾아 볼 수 있습니다.

160+#### `git diff`

161+

162+`bat`과 `git diff`를 함께 사용하여 수정된 코드 주위의 줄들을 올바른 문법 강조로

163+볼 수 있습니다:

164+```bash

165+batdiff() {

166+ git diff --name-only --diff-filter=d | xargs bat --diff

167+}

168+```

169+이것을 별도의 도구로 쓰고 싶다면

170+[`bat-extras`](https://github.com/eth-p/bat-extras)의 `batdiff`를 확인해 보세요.

171+

172+Git과 diff의 더 많은 지원을 원한다면

173+[`delta`](https://github.com/dandavison/delta)를 확인해 보세요.

127174

128175#### `xclip`

129176

130−`bat` 출력에서 라인 넘버와 Git 수정 내역이 같이 있어 파일 내용을 복사하기가 어려울 수도 있습니다. 이 경우에는 `-p`/`--plain` 옵션을 사용 하거나 출력 시 파이프라인으로 `xclip`을 사용하면 됩니다:

177+`bat` 출력에 줄 번호와 Git 수정 내역이 포함되어서 파일의 내용을 복사하기

178+어려울 수 있습니다.

179+이 경우에는 `bat`의 `-p`/`--plain` 옵션을 사용하거나 간단히 `xclip`으로 출력을

180+연결(pipe)하면 됩니다:

131181```bash

132182bat main.cpp | xclip

133183```

134−`bat` 에서는 리다이렉트된 것으로 감지하여, 파일 내용만 출력합니다.

184+`bat`는 출력이 우회되고 있다는 것을 감지하여 파일 내용 그대로를 출력합니다.

135185

136186#### `man`

137187

138−`bat`은 `MANPAGER` 환경 변수 설정을 통해 `man`에 대하여 컬러 페이져를 사용할 수 있습니다:

188+`MANPAGER` 환경 변수 설정을 통해 `bat`을 `man`의 컬러 페이저(pager)로 쓸 수

189+있습니다.

139190

140191```bash

141192export MANPAGER="sh -c 'col -bx | bat -l man -p'"

142193man 2 select

143194```

195+(Debian이나 Ubuntu를 사용한다면 `bat`을 `batcat`으로 치환하세요.)

144196

145−포매팅 문제가 발생한다면, `MANROFFOPT="-c"` 설정 해야 할 수도 있습니다 .

197+포팻 문제가 발생한다면, `MANROFFOPT="-c"`을 써야 할 수 있습니다.

146198

147−새 커맨드에서 이 번들을 사용하려면, [`batman`](https://github.com/eth-p/bat-extras/blob/master/doc/batman.md)을 이용 할 수 있습니다.

199+이 기능을 포함한 새로운 명령어를 선호한다면,

200+[`batman`](https://github.com/eth-p/bat-extras/blob/master/doc/batman.md)을 쓸

201+수도 있습니다.

148202

203+참고로 [Manpage 문법](../assets/syntaxes/Manpage.sublime-syntax)은 본 저장소에서

204+개발 중에 있으며, 아직 더 손봐야 합니다.

149205

150−참고 : [Manpage syntax](../assets/syntaxes/Manpage.sublime-syntax)는 이 저장소에서 개발되고 있으며, 아직 작업 중 입니다.

206+또한, 이는 Mandoc의 `man` 구현에서

207+[작동하지 않습니다](https://github.com/sharkdp/bat/issues/1145).

151208

152209#### `prettier` / `shfmt` / `rustfmt`

153210

154−[`prettybat`](https://github.com/eth-p/bat-extras/blob/master/doc/prettybat.md) 스크립트는 코드를 포맷팅하고 `bat`으로 출력해주는 랩퍼(wrapper) 입니다.

211+[`prettybat`](https://github.com/eth-p/bat-extras/blob/master/doc/prettybat.md)

212+스크립트는 코드를 포맷하고 `bat`으로 출력하는 래퍼(wrapper)입니다.

155213

156214

157215## 설치

158216

159−[![Packaging status](https://repology.org/badge/vertical-allrepos/bat.svg)](https://repology.org/project/bat/versions)

217+[![Packaging status](https://repology.org/badge/vertical-allrepos/bat-cat.svg)](https://repology.org/project/bat-cat/versions)

160218

161−### On Ubuntu

162−*... 그리고 기타 Debian 기반의 Linux 배포판들.*

219+### Ubuntu에서 (`apt` 사용)

220+*... 그리고 다른 Debian 기반의 Linux 배포판들에서.*

163221

164−Ubuntu Eoan 19.10 혹은 Debian unstable sid 이후 버전 부터는 [Ubuntu용 `bat` 패키지](https://packages.ubuntu.com/eoan/bat)나 [Debian용 `bat` 패키지](https://packages.debian.org/sid/bat) 를 설치 할 수 있습니다.

222+`bat`은 [Ubuntu](https://packages.ubuntu.com/eoan/bat)와

223+[Debian](https://packages.debian.org/sid/bat) 패키지 배포 과정에 도입되는 중이며,

224+Eoan 19.10 버전의 Ubuntu에서부터 제공됩니다.

225+현재 Debian에서는 불안정한 "Sid" 브랜치에서만 `bat`이 제공됩니다.

226+

227+만약 충분히 최신 버전의 Ubuntu/Debian이 설치되어 있다면 간단히 다음을 실행하세요:

165228

166229```bash

167230apt install bat

168231```

169232

170−만약 최근 릴리즈된 bat을 사용을 원하거나 buntu/Debian 예전 버전을 사용하는 경우, [릴리즈 페이지](https://github.com/sharkdp/bat/releases)에서 다음과 같이 `.deb` 패키지를 받아 설치 할 수도 있습니다:

233+**중요**: 만약 `bat`을 이와 같이 설치한다면, ([다른 패키지와의 이름

234+충돌](https://github.com/sharkdp/bat/issues/982)로 인하여) `bat` 대신에

235+`batcat`이라는 이름의 실행 파일로 설치될 수 있음을 참고하세요.

236+이에 따른 문제들과 다른 배포판들과의 일관성을 위하여 `bat -> batcat` symlink

237+혹은 alias를 설정할 수 있습니다:

238+``` bash

239+mkdir -p ~/.local/bin

240+ln -s /usr/bin/batcat ~/.local/bin/bat

241+```

242+

243+### Ubuntu에서 (가장 최신 `.deb` 패키지들 사용)

244+*... 그리고 다른 Debian 기반의 Linux 배포판들에서.*

245+

246+만약 여러분이 설치한 Ubuntu/Debian에 패키지가 배포되지 않거나 가장 최신 릴리즈된

247+`bat`을 원한다면, [릴리즈 페이지](https://github.com/sharkdp/bat/releases)에서

248+다음과 같이 `.deb` 패키지를 받아 설치하세요:

171249

172250```bash

173−sudo dpkg -i bat_0.17.1_amd64.deb # adapt version number and architecture

251+sudo dpkg -i bat_0.18.3_amd64.deb # adapt version number and architecture

174252```

175253

176−### On Alpine Linux

254+### Alpine Linux에서

177255

178−공식 소스를 통해 [`bat` 패키지](https://pkgs.alpinelinux.org/packages?name=bat) 를 설치 할 수 있습니다:

256+적절한 저장소가 활성화되어 있다면, 공식 소스를 통해

257+[`bat` 패키지](https://pkgs.alpinelinux.org/packages?name=bat)를 설치할 수

258+있습니다:

179259

180260```bash

181261apk add bat

182262```

183263

184−### On Arch Linux

264+### Arch Linux에서

185265

186−공식 소스를 통해 [`bat` 패키지](https://www.archlinux.org/packages/community/x86_64/bat/)를 설치할 수 있습니다:

266+공식 소스를 통해

267+[`bat` 패키지](https://www.archlinux.org/packages/community/x86_64/bat/)를

268+설치할 수 있습니다:

187269

188270```bash

189271pacman -S bat

190272```

191273

192−### On Fedora

274+### Fedora에서

193275

194−[공식 Fedora 모듈 저장소](https://docs.fedoraproject.org/en-US/modularity/using-modules/)에서 [`bat` 패키지](https://koji.fedoraproject.org/koji/packageinfo?packageID=27506)을 설치할 수 있습니다:

276+공식

277+[Fedora 모듈](https://docs.fedoraproject.org/en-US/modularity/using-modules/)

278+저장소에서

279+[`bat` 패키지](https://koji.fedoraproject.org/koji/packageinfo?packageID=27506)를

280+설치할 수 있습니다:

195281

196282```bash

197283dnf install bat

198284```

199285

200−### On Gentoo Linux

286+### Funtoo Linux에서

287+

288+dev-kit을 통해 [`bat` 패키지](https://github.com/funtoo/dev-kit/tree/1.4-release/sys-apps/bat)를 설치할 수 있습니다:

289+

290+```bash

291+emerge sys-apps/bat

292+```

293+

294+### Gentoo Linux에서

201295

202−공식 소스를 통해 [`bat` 패키지](https://packages.gentoo.org/packages/sys-apps/bat)를 설치할 수 있습니다.

296+공식 소스를 통해

297+[`bat` 패키지](https://packages.gentoo.org/packages/sys-apps/bat)를 설치할 수

298+있습니다:

203299

204300```bash

205301emerge sys-apps/bat

206302```

207303

208−### On Void Linux

304+### Void Linux에서

209305

210−xbps-install를 이용해 `bat`을 설치할 수 있습니다:

306+xbps-install을 이용해 `bat`을 설치할 수 있습니다:

211307```bash

212308xbps-install -S bat

213309```

214310

215−### On FreeBSD

311+### Termux에서

312+

313+pkg를 이용해 `bat`을 설치할 수 있습니다:

314+```bash

315+pkg install bat

316+```

317+

318+### FreeBSD에서

216319

217−pkg를 이용하여 미리 컴파일된 [`bat` 패키지](https://www.freshports.org/textproc/bat)를 설치할 수 있습니다:

320+pkg를 이용하여 미리 컴파일된

321+[`bat` 패키지](https://www.freshports.org/textproc/bat)를 설치할 수 있습니다:

218322

219323```bash

220324pkg install bat

221325```

222326

223−또는 FreeBSD 포트에서 직접 빌드할 수도 있습니다:

327+또는 FreeBSD 포트에서 직접 빌드할 수도 있습니다:

224328

225329```bash

226330cd /usr/ports/textproc/bat

227331make install

228332```

229333

230−### Via nix

334+### nix를 써서

231335

232−[nix package manager](https://nixos.org/nix)를 이용해 `bat`을 설치할 수 있습니다:

336+[nix package manager](https://nixos.org/nix)를 이용해 `bat`을 설치할 수

337+있습니다:

233338

234339```bash

235340nix-env -i bat

236341```

237342

238−### On openSUSE

343+### openSUSE에서

239344

240−zypper을 이용해 `bat`을 설치할 수 있습니다:

345+zypper를 이용해 `bat`을 설치할 수 있습니다:

241346

242347```bash

243348zypper install bat

244349```

245350

246−### On macOS

351+### snap 패키지를 써서

352+

353+지금으로서는 추천하는 snap 패키지가 없습니다.

354+제공되는 패키지들이 존재할 수는 있지만, 공식적으로 지원되지 않으며

355+[문제](https://github.com/sharkdp/bat/issues/1519)가 있을 수 있습니다.

356+

247357

248−[Homebrew](http://braumeister.org/formula/bat)를 이용해 `bat`을 설치할 수 있습니다:

358+### macOS (또는 Linux)에서 Homebrew를 써서

359+

360+[macOS의 Homebrew](https://formulae.brew.sh/formula/bat) 또는

361+[Linux의 Homebrew](https://formulae.brew.sh/formula-linux/bat)를 이용하여

362+`bat`을 설치할 수 있습니다.

249363

250364```bash

251365brew install bat

252366```

253367

254−또는 [MacPorts](https://ports.macports.org/port/bat/summary)를 사용할 수도 있습니다:

368+### macOS에서 MacPorts를 써서

369+

370+[MacPorts](https://ports.macports.org/port/bat/summary)를 이용하여 `bat`을

371+설치할 수 있습니다:

255372

256373```bash

257374port install bat

258375```

259376

260−### On Windows

377+### Windows에서

261378

262−Windows에서 `bat`을 설치할 수 있는 몇 가지 옵션들이 있습니다. 먼저 `bat`을 설치 한 후, ["Windows에서 사용하기"](#Windows에서-사용하기) 참고하시기 바랍니다.

379+Windows에서 `bat`을 설치할 수 있는 몇 가지 옵션들이 있습니다.

380+먼저 `bat`을 설치한 후,

381+["Windows에서 `bat` 사용하기"](#windows에서-bat-사용하기) 섹션을 살펴보세요.

263382

264−#### With Chocolatey

383+#### 전제 조건

265384

266−[Chocolatey](https://chocolatey.org/packages/Bat)를 이용해 `bat`을 설치할 수 있습니다:

385+[Visual C++ 재배포 가능](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads)

386+패키지를 설치해야 합니다.

387+

388+#### Chocolatey를 써서

389+

390+[Chocolatey](https://chocolatey.org/packages/Bat)를 이용해 `bat`을 설치할 수

391+있습니다:

267392```bash

268393choco install bat

269394```

270395

271−#### With Scoop

396+#### Scoop을 써서

272397

273398[scoop](https://scoop.sh/)을 이용해 `bat`을 설치할 수 있습니다:

274399```bash

275400scoop install bat

276401```

277−[Visual C++ Redistributable 패키지](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads)를 같이 설치해 주어야 합니다.

278402

279−#### From prebuilt binaries:

403+#### 사전 빌드된 바이너리들로

280404

281−[릴리즈 페이지](https://github.com/sharkdp/bat/releases)에서 빌드된 바이너리를 다운받을 수 있습니다.

405+[릴리즈 페이지](https://github.com/sharkdp/bat/releases)에서 사전 빌드된

406+바이너리를 다운받을 수 있습니다.

282407

283−[Visual C++ Redistributable 패키지](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads)를 같이 설치해 주어야 합니다.

408+[Visual C++ 재배포 가능](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads)

409+패키지를 설치해야 합니다.

284410

285−### Via Docker

411+### 바이너리들로

286412

287−컨테이너에서 `bat`을 사용할 수 있는 [Docker image](https://hub.docker.com/r/danlynn/bat/)가 있습니다.:

288−```bash

289−docker pull danlynn/bat

290−alias bat='docker run -it --rm -e BAT_THEME -e BAT_STYLE -e BAT_TABS -v "$(pwd):/myapp" danlynn/bat'

291−```

413+[릴리즈 페이지](https://github.com/sharkdp/bat/releases)에서 다양한 아키텍처를

414+위해 사전 빌드된 버전들을 확인할 수 있습니다.

415+정적 링크 바이너리들은 파일 이름에 `musl` 이 포함된 아카이브들을 확인하세요.

292416

293−### Via Ansible

417+### 소스에서

294418

295−[Ansible](https://www.ansible.com/)을 사용해 `bat`을 설치할 수 있습니다:

419+`bat`의 소스를 빌드하기 위해서는, Rust 1.51 이상이 필요합니다.

420+`cargo`를 이용해 전부 빌드할 수 있습니다:

296421

297422```bash

298−# Install role on local machine

299−ansible-galaxy install aeimer.install_bat

300−```

301−

302−```yaml

303−---

304−# Playbook to install bat

305−- host: all

306− roles:

307− - aeimer.install_bat

423+cargo install --locked bat

308424```

309425

310−- [Ansible Galaxy](https://galaxy.ansible.com/aeimer/install_bat)

311−- [GitHub](https://github.com/aeimer/ansible-install-bat)

312−

313−다음 배포판들에서 동작합니다:

314−- Debian/Ubuntu

315−- ARM (eg. Raspberry PI)

316−- Arch Linux

317−- Void Linux

318−- FreeBSD

319−- MacOS

426+참고로 man 페이지나 셸 자동 완성 파일과 같은 부가 파일들은 이 방법으로 설치될 수

427+없습니다.

428+이것들은 `cargo`에 의해 생성이 되고 (`build` 밑의) cargo 타켓 폴더에서 찾을 수

429+있습니다.

320430

321−### From binaries

431+## 사용자화

322432

323−[릴리즈 페이지](https://github.com/sharkdp/bat/releases)에서 다양한 환경을 위해 빌드된 버전들을 확인 할 수 있습니다. 정적 링크 바이너리들은 아카이브에서 파일 이름에 `musl` 이 포함 파일로 확인 할 수 있습니다.

433+### 문법 강조 테마

324434

325−### From source

435+`bat --list-themes`을 사용하여 사용 가능한 문법 강조 테마들의 목록을 확인할 수

436+있습니다.

437+`TwoDark` 테마를 선택하려면, `--theme=TwoDark` 옵션과 함께 `bat`을 사용하거나

438+`BAT_THEME` 환경 변수를 `TwoDark`로 설정하세요.

439+셸 시작 파일에 `export BAT_THEME="TwoDark"` 를 정의해 영구적으로 설정할 수

440+있습니다.

441+이 밖에 `bat`의 [설정 파일](#설정-파일)을 이용할 수 있습니다.

326442

327−`bat`의 소스를 직접 빌드하기 위해서는, Rust 1.36 이상이 필요하며 `cargo`를 이용해 빌드할 수 있습니다.

443+만약 다른 테마들을 사용하여 특정 파일을 보고 싶다면, 다음 명령어를 쓸 수

444+있습니다(이 경우 [`fzf`](https://github.com/junegunn/fzf)가 필요합니다.)

328445

329446```bash

330−cargo install --locked bat

447+bat --list-themes | fzf --preview="bat --theme={} --color=always /path/to/file"

331448```

332449

333−일부 플랫폼에서는 `llvm` 그리고/또는 `libclang-dev` 설치가 필요할 수도 있습니다.

450+`bat`은 기본적으로 어두운 배경에 적합합니다.

451+그러나 밝은 배경의 터미널을 사용한다면 `GitHub`이나 `OneHalfLight`과 같은 테마가

452+더 잘 어울립니다.

453+아래 [새로운 테마 추가하기](#새로운-테마-추가하기) 섹션에 따라 커스텀 테마를

454+사용할 수도 있습니다.

334455

335−## 커스터마이즈

456+### 8비트 테마

336457

337−### 문법 강조 테마

458+`bat`은 트루컬러 지원이 되더라도 항상

459+[8비트 색상](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors)을 사용하는

460+세 개의 테마가 있습니다.

338461

339−`bat --list-themes`을 사용하면, 현재 사용 가능한 문법 강조 테마들을 확인할 수 있습니다. `TwoDark` 테마 선택하는 경우, `--theme=TwoDark` 옵션과 함께 `bat`을 사용하거나 환경변수에서 `BAT_THEME`를 `TwoDark`로 세팅해주면 됩니다. 쉘 시작 파일에 `export BAT_THEME="TwoDark"` 를 정의해 계속 사용도 가능합니다. 이 밖에 `bat`의 [설정 파일](#설정-파일)을 이용할 수도 있습니다.

462+- `ansi`는 어떤 터미널에서도 무난하게 보입니다. 이는 3비트 색상을 사용합니다:

463+ 검정, 빨강, 녹색, 노랑, 파랑, 마젠타, 시안, 하양.

464+- `base16`은 [base16](https://github.com/chriskempson/base16) 터미널 테마를 위해

465+ 디자인되었습니다.

466+ 이는 [base16 스타일 가이드라인](https://github.com/chriskempson/base16/blob/master/styling.md)에

467+ 따라 4비트 색상(3비트 색상에 밝은 변형 추가)을 사용합니다.

468+- `base16-256`는 [base16-shell](https://github.com/chriskempson/base16-shell)을

469+ 위해 디자인되었습니다.

470+ 이는 16부터 21의 일부 밝은 색상을 8비트 색상으로 대치합니다.

471+ 단지 256-색상 터미널을 쓰지만 base16-shell을 쓰지 않는다고 해서 이것을

472+ 사용하지 **마십시오**.

340473

341−다른 테마를 미리 보고 싶은경우 다음 명령어와 같이 사용할 수 있습니다.(이 경우 [`fzf`](https://github.com/junegunn/fzf)가 필요합니다.)

474+이들 테마는 더 제한적이지만, 트루컬러 테마에 비해 두 장점이 있습니다:

342475

343−```bash

344−bat --list-themes | fzf --preview="bat --theme={} --color=always /path/to/file"

345−```

346−`bat`의 기본 테마는 어두운 배경색 터미널에 적합합니다. 만일 밝은 배경색을 사용할 경우에는 `GitHub` 이나 `OneHalfLight` 과 같은 테마가 더 잘 어울립니다. 아래 [새로운 테마 추가하기](#새로운-테마-추가하기)에 따라 커스텀 테마를 사용할수도 있습니다.

476+- 이들은 3비트 혹은 4비트 색상을 쓰는 다른 터미널 소프트웨어와 더 잘

477+ 어울립니다.

478+- 만약 터미널 테마를 바꾼다면, 이미 화면 상의 `bat`의 출력도 이에 맞추어

479+ 업데이트됩니다.

347480

348481### 출력 스타일

349482

350−`--style` 옵션을 이용하여 `bat`의 출력 스타일을 변경 할 수 있습니다. 예를 들어, `--style=numbers,changes`는 Git 변경분과 라인 넘버에 대해서만 출력하며 눈금과 파일 헤더가 표시되지 않습니다. `BAT_STYLE` 환경 변수로 정의하여 계속해서 사용하거나`bat`의 [설정 파일](#설정-파일)을 사용할 수도 있습니다.

483+`--style` 옵션을 이용하면 `bat`의 출력 모양을 조절할 수 있습니다.

484+예를 들어, `--style=numbers,changes`를 통해 Git 변경분과 줄 번호는 출력하지만

485+격자와 파일 헤더는 출력하지 않을 수 있습니다.

486+`BAT_STYLE` 환경 변수를 정의하여 이러한 수정을 영구적으로 하거나 `bat`의

487+[설정 파일](#설정-파일)을 사용하세요.

351488

352−### 새로운 문법 강조 / 언어 추가하기

489+### 새로운 문법 / 언어 정의 추가하기

353490

354−`bat`은 문법 강조를 위해 [`syntect`](https://github.com/trishume/syntect/) 라이브러리를 사용하고 있습니다. `syntect`는 [Sublime Text의 `.sublime-syntax` 파일](https://www.sublimetext.com/docs/3/syntax.html)과 테마를 읽을 수 있습니다. 새로운 문법 강조를 추가하는 방법은 다음과 같습니다.

491+만약 `bat`에서 특정 문법이 지원되지 않을 경우, 다음의 절차를 통해 현재 `bat`

492+설치본에 새로운 문법을 쉽게 추가할 수 있습니다.

355493

356−우선 문법 정의 파일을 넣을 폴더를 만듭니다:

494+`bat`은 문법 강조를 위해 훌륭한

495+[`syntect`](https://github.com/trishume/syntect/) 라이브러리를 사용합니다.

496+`syntect`는 임의의 [Sublime Text의 `.sublime-syntax`

497+파일](https://www.sublimetext.com/docs/3/syntax.html)과 테마를 읽을 수 있습니다.

357498

358−```bash

359−mkdir -p "$(bat --config-dir)/syntaxes"

360−cd "$(bat --config-dir)/syntaxes"

499+[Package Control](https://packagecontrol.io/)에 Sublime 문법 패키지를 찾는

500+방법이 잘 정리되어 있습니다.

501+일단 문법을 찾았다면:

361502

362−# Put new '.sublime-syntax' language definition files

363−# in this folder (or its subdirectories), for example:

364−git clone https://github.com/tellnobody1/sublime-purescript-syntax

365−```

503+1. 문법 정의 파일들을 넣을 폴더를 만듭니다:

366504

367−다음 명령어를 통해 파일을 바이너리 캐시로 파싱합니다.

505+ ```bash

506+ mkdir -p "$(bat --config-dir)/syntaxes"

507+ cd "$(bat --config-dir)/syntaxes"

368508

369−```bash

370−bat cache --build

371−```

509+ # Put new '.sublime-syntax' language definition files

510+ # in this folder (or its subdirectories), for example:

511+ git clone https://github.com/tellnobody1/sublime-purescript-syntax

512+ ```

372513

373−마지막으로 `bat --list-languages`을 통해 새로운 언어가 사용 가능한지 확인합니다.

514+2. 이제 다음 명령어를 통해 파일들을 파싱(parse)하여 바이너리 캐시를 만듭니다.

374515

375−기본 설정으로 돌아가려면, 다음 명령어를 이용합니다.:

516+ ```bash

517+ bat cache --build

518+ ```

376519

377−```bash

378−bat cache --clear

379−```

520+3. 마지막으로, `bat --list-languages`로 새로 추가한 언어가 사용 가능한지

521+ 확인합니다.

522+

523+ 만약 기본 설정으로 돌아갈 일이 생긴다면, 다음 명령어를 이용합니다:

524+

525+ ```bash

526+ bat cache --clear

527+ ```

528+

529+4. 만약 특정 문법이 `bat`에 기본적으로 포함되어 있어야 한다고 생각한다면, 방침과

530+ 절차를 [여기](../doc/assets.md)서 읽은 후 "문법 요청(syntax request)"을 열어

531+ 주세요: [문법 요청하기](https://github.com/sharkdp/bat/issues/new?labels=syntax-request&template=syntax_request.md).

380532

381533### 새로운 테마 추가하기

382534

383−새로운 문법 정의 추가와 매우 유사합니다.

535+이 과정은 새로운 문법 정의 추가 방식과 매우 비슷합니다.

384536

385−먼저, 새로운 문법 강조 테마 폴더를 만듭니다.

537+먼저, 새로운 문법 강조 테마 폴더를 만듭니다.

386538```bash

387539mkdir -p "$(bat --config-dir)/themes"

388540cd "$(bat --config-dir)/themes"

@@ -394,32 +546,93 @@ git clone https://github.com/greggb/sublime-snazzy

394546bat cache --build

395547```

396548

397−마지막으로 `bat --list-themes`을 통해 새로운 테마가 사용 가능한지 확인합니다.

549+마지막으로 `bat --list-themes`을 통해 새로 추가한 테마들이 사용 가능한지

550+확인합니다.

551+

552+### 파일 타입 설정을 추가하거나 변경하기

553+

554+새로운 파일 이름 패턴을 추가하려면 (혹은 이미 존재하는 것을 변경하려면)

555+`--map-syntax` 커맨드 라인 옵션을 사용하세요.

556+이 옵션은 `pattern:syntax` 꼴의 인자를 받습니다.

557+이때 `pattern`은 파일 이름과 절대 파일 경로를 매치할 글로브(glob) 패턴입니다.

558+`syntax` 부분은 지원되는 언어의 전체 이름입니다

559+(`bat --list-languages`를 통해 개요를 확인하세요).

560+

561+참고: 이 옵션은 커맨드 라인에 넘겨 주는 것보다는 `bat`의 설정 파일에 넣는 것이

562+좋을 것입니다 (아래를 보세요).

563+

564+예시: "INI" 문법 강조를 `.conf` 파일 확장자의 모든 파일에 적용하려면, 다음을

565+사용하세요:

566+```bash

567+--map-syntax='*.conf:INI'

568+```

569+

570+예시: `.ignore`(완전 일치)이라는 이름의 모든 파일을 "Git Ignore" 문법으로

571+열려면, 다음을 사용하세요:

572+```bash

573+--map-syntax='.ignore:Git Ignore'

574+```

575+

576+예시: `/etc/apache2`의 하위 폴더들에 있는 모든 `.conf` 파일들을 "Apache Conf"

577+문법으로 열려면, 다음을 사용하세요 (이 대응(mapping)은 이미 내장되어 있습니다):

578+```bash

579+--map-syntax='/etc/apache2/**/*.conf:Apache Conf'

580+```

398581

399−### 다른 페이져 사용하기

582+### 다른 페이저 사용하기

400583

401−`bat`은 환경변수 `PAGER`로 사용할 페이져를 명시합니다. 만약 이 변수가 정의되어있지 않다면 `less`가 기본입니다. 만약 다른 페이져를 사용하고 싶다면 `PAGER` 변수를 수정하거나 `BAT_PAGER` 환경 변수로 `PAGER` 대신 정의 할 수도 있습니다.

584+`bat`은 환경 변수 `PAGER`에 명시된 페이저를 사용합니다.

585+이 변수가 정의되어 있지 않다면, `less`가 기본으로 사용됩니다.

586+만약 다른 페이저를 사용하고 싶다면, `PAGER` 변수를 수정하거나 `BAT_PAGER` 환경

587+변수를 설정하여 `PAGER`의 설정을 오버라이드(override)할 수 있습니다.

402588

403−만약 커맨드라인 인수로 넘기려면, `PAGER`/`BAT_PAGER` 변수를 정의를 통해 사용 할 수 있습니다. :

589+만약 커맨드라인 인수들을 페이저에게 넘겨 주려면, `PAGER`/`BAT_PAGER` 변수로

590+설정할 수 있습니다:

404591

405592```bash

406593export BAT_PAGER="less -RF"

407594```

408595

409−환경 변수 대신, `bat`의 [설정 파일](#설정-파일)에서 페이져를 설정 할 수도 있습니다.(`--pager` 옵션)

596+환경 변수를 사용하는 대신, `bat`의 [설정 파일](#설정-파일)로 페이저를 설정할

597+수도 있습니다 (`--pager` 옵션).

410598

411−**참고**: 기본적으로 페이져가 `less`로 설정 되어있다면, `bat`은 다음 옵션들을 받을 수 있습니다: `-R`/`--RAW-CONTROL-CHARS`,

412−`-F`/`--quit-if-one-screen` 그리고 `-X`/`--no-init`. 마지막 옵션(`-X`)은 530 이전 버전에서만 사용됩니다.

599+**참고**: 기본적으로, 페이저가 `less`로 설정되어 있다면 (그리고 커맨드 라인

600+옵션이 지정되어 있지 않다면), `bat`은 다음 옵션들을 페이저로 넘겨줍니다:

601+`-R`/`--RAW-CONTROL-CHARS`, `-F`/`--quit-if-one-screen` 그리고 `-X`/`--no-init`.

602+마지막 옵션(`-X`)은 530 이전 버전의 `less`에만 사용됩니다.

413603

414−`-R` 옵션은 ANSI 컬러를 올바르게 해석하기 위해 필요합니다. 두번째 옵션 (`-F`)은 출력 크기가 터미널의 세로 크기보다 작을 경우 즉시 종료되도록 합니다.

415−페이져를 종료하기 위해 `q`를 누를 필요 없기 때문에 작은 파일을 다룰 때 용이합니다. 세번째 옵션(`-X`)는 `less` 이전 버전의 `--quit-if-one-screen` 기능과 함께 버그를 잡을 때 필요합니다. 안타깝게도, `less`의 마우스 휠 지원은 종료합니다.

604+`-R` 옵션은 ANSI 색상을 올바르게 해석하기 위해 필요합니다.

605+두 번째 옵션(`-F`)은 출력 크기가 터미널의 세로 크기보다 작을 경우 less가 즉시

606+종료되도록 합니다.

607+이는 작은 파일을 다룰 때 페이저를 종료하기 위해 `q`를 누를 필요 없어서

608+편리합니다.

609+세 번째 옵션(`-X`)는 예전 버전의 `less`에 있는 `--quit-if-one-screen` 기능의

610+버그를 고치기 위해 필요합니다.

611+안타깝게도, 이는 `less`의 마우스 휠 지원과 호환되지 않습니다.

416612

417−`less` 예전 버전에서 마우스 휠 기능을 활성화 시키려면, `-R` 옵션을 사용하면 됩니다. (위의 예제처럼, 이 옵션은 quit-if-one-screen 기능을 비활성화 시킵니다.)

418−530 이하 버전에서는 그대로 사용할 수 있습니다.

613+`less`의 예전 버전에서 마우스 휠 기능을 활성화하려면, `-R` 옵션을 넘겨주세요

614+(위의 예제처럼, 이 옵션은 quit-if-one-screen 기능을 비활성화합니다).

615+less 530과 이후 버전에서는 그대로 사용할 수 있습니다.

616+

617+### 들여쓰기

618+

619+`bat`은 페이저에 의존하지 않고 탭을 4 스페이스로 확장합니다.

620+이를 변경하려면 간단히 `--tabs` 인자에 표시되기를 원하는 스페이스 개수를

621+추가하세요.

622+

623+**참고**: (`bat`의 `--pager` 인자 혹은 `less`의 `LESS` 환경 변수를 통해)

624+페이저의 탭 길이를 지정하는 것은 효과가 없을 것인데, 이는 페이저가 이미

625+스페이스로 확장된 탭을 받기 때문입니다.

626+이 기능은 사이드바에 의한 들여쓰기 문제를 회피하기 위해 추가되었습니다.

627+`bat`을 `--tabs=0`과 함께 호출하면 이를 오버라이드하여 페이저가 탭을 처리하게

628+합니다.

419629

420630### 다크 모드

421631

422−macOS에서 다크 모드를 사용하고 있다면, OS 테마에 따라 다른 테마를 사용하도록 `bat`의 구성할 수 있습니다. 아래 코드는 라이트 모드에서는 `default` 테마를 다크모드에서는 `Github` 테마를 사용하는 방법입니다.

632+macOS에서 다크 모드를 사용하고 있다면, `bat`가 OS 테마에 따라 다른 테마를

633+사용하도록 구성할 수 있습니다.

634+아래 스니펫은 _다크 모드_에서는 `default` 테마를, _라이트 모드_에서는 `GitHub`

635+테마를 사용하는 방법입니다.

423636

424637```bash

425638alias cat="bat --theme=\$(defaults read -globalDomain AppleInterfaceStyle &> /dev/null && echo default || echo GitHub)"

@@ -427,57 +640,89 @@ alias cat="bat --theme=\$(defaults read -globalDomain AppleInterfaceStyle &> /de

427640

428641## 설정 파일

429642

430−`bat` 설정 파일로 커스터마이즈 할 수 있습니다. 파일의 위치는 운영 체제에 따라 다릅니다. 아래 커맨드를 통해 시스템의 기본 경로를 알 수 있습니다.

643+`bat`는 설정 파일로도 사용자화 할 수 있습니다.

644+설정 파일의 위치는 운영 체제에 따라 다릅니다.

645+아래 커맨드를 통해 시스템의 기본 경로를 확인할 수 있습니다.

431646```

432647bat --config-file

433648```

434649

435−또는, `BAT_CONFIG_PATH` 환경 변수를 사용하여 `bat`의 설정 파일 위치를 지정할 수 있습니다.

650+또는, `BAT_CONFIG_PATH` 환경 변수를 사용하여 `bat`가 설정 파일의 기본 경로

651+이외의 위치를 사용하도록 할 수 있습니다.

436652```bash

437653export BAT_CONFIG_PATH="/path/to/bat.conf"

438654```

439655

656+기본 설정 파일은 `--generate-config-file` 옵션으로 생성할 수 있습니다.

657+```bash

658+bat --generate-config-file

659+```

660+

440661### 포맷

441662

442−설정 파일은 명령어 인수들의 리스트 입니다. `bat --help`를 이용하여 가능한 옵션들과 값들을 확인해 볼 수 있습니다. 또, `#` 으로 주석을 추가할수도 있습니다.

663+설정 파일은 단순히 커맨드 라인 인자들의 리스트입니다.

664+`bat --help`로 가능한 모든 옵션과 값들을 확인하세요.

665+추가적으로, 줄 앞에 `#` 문자를 추가해 주석을 넣을 수 있습니다.

443666

444−설정 파일의 예:

667+설정 파일 예시:

445668```bash

446−# Set the theme to "TwoDark"

669+# "TwoDark" 테마 설정하기

447670--theme="TwoDark"

448671

449−# Show line numbers, Git modifications and file header (but no grid)

672+# 줄 번호, Git 변경 내용, 파일 헤더 보이기 (격자 없이)

450673--style="numbers,changes,header"

451674

452−# Use italic text on the terminal (not supported on all terminals)

675+# 터미널에서 이탤릭체 쓰기 (일부 터미널에서 미지원)

453676--italic-text=always

454677

455−# Use C++ syntax for .ino files

678+# Arduino .ino 파일에 C++ 문법 쓰기

456679--map-syntax "*.ino:C++"

457−

458−# Use ".gitignore"-style highlighting for ".ignore" files

459−--map-syntax ".ignore:Git Ignore"

460680```

461681

462−## Windows에서 사용하기

682+## Windows에서 `bat` 사용하기

683+

684+`bat`는 대부분의 경우 Windows에서 기본적으로 잘 작동하지만, 일부 기능은 추가적인

685+구성이 필요할 수 있습니다.

463686

464−`bat` 대부분의 경우 Windows에서 기본적으로 잘 작동하지만, 일부 기능에는 추가 적인 구성이 필요할 수 있습니다.

687+#### 전제 조건

465688

466−### 페이징

689+[Visual C++ 재배포 가능](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads)

690+패키지를 설치해야 합니다.

467691

468−Windows는 `more` 형식의 매우 제한된 페이저만이 포함되어있습니다. `less`용 Windows 바이너리는 [이 홈페이지](http://www.greenwoodsoftware.com/less/download.html)나 [Chocolatey](https://chocolatey.org/packages/Less)에서 다운로드 받을 수 있습니다. 이를 사용하려면 바이너리를 `PATH` 디렉토리에 배치하거나 [환경 변수로 정의](#using-a-different-pager) 하세요. [Chocolatey 패키지](#on-windows)로 `less`를 자동으로 설치할 수 있습니다.

692+### 페이징

693+

694+Windows는 `more` 형식의 매우 제한된 페이저만 포함합니다.

695+Windows용 `less` 바이너리는

696+[공식 홈페이지](http://www.greenwoodsoftware.com/less/download.html)나

697+[Chocolatey](https://chocolatey.org/packages/Less)를 통해 다운로드 받을 수

698+있습니다.

699+이를 사용하려면 디렉터리 안의 바이너리를 `PATH`에 넣거나

700+[환경 변수로 정의](#using-a-different-pager)하세요.

701+[Chocolatey 패키지](#on-windows)는 `less`를 자동으로 설치합니다.

469702

470703### 색상

471704

472−Windows 10은 기본 내장기능으로 [v1511](https://en.wikipedia.org/wiki/Windows_10_version_history#Version_1511_(November_Update)) 이후의 `conhost.exe`(Command Prompt) 와 PowerShell, 그리고 최신 버전의 bash에서 색상을 지원합니다. 이전 버전의 Windows에서는, [ConEmu](https://conemu.github.io/)가 포함 된 [Cmder](http://cmder.net/)를 사용할 수 있습니다 .

705+Windows 10은

706+[v1511](https://en.wikipedia.org/wiki/Windows_10_version_history#Version_1511_(November_Update))부터

707+기본적으로 `conhost.exe`(Command Prompt)와 PowerShell에서 색상을 지원하며,

708+최신 버전의 bash에서도 색상을 지원합니다.

709+이전 버전의 Windows에서는, [ConEmu](https://conemu.github.io/)가 포함된

710+[Cmder](http://cmder.net/)를 사용할 수 있습니다.

473711

474−**참고:** `less`의 Git과 MSYS 버전은 Windows에서 색상을 올바르게 해석하지 않습니다. 다른 페이져가 설치되어 있지 않은 경우, `--paging=never` 하거나 `BAT_PAGER`를 빈 문자열로 설정하여 페이징을 완전히 비활성화 할 수 있습니다 .

712+**참고:** Git과 MSYS 버전의 `less`는 Windows에서 색상을 올바르게 해석하지

713+않습니다.

714+다른 페이저가 설치되어 있지 않은 경우, `--paging=never`을 넘겨주거나

715+`BAT_PAGER`을 빈 문자열로 설정하여 페이징을 완전히 비활성화 할 수 있습니다.

475716

476717### Cygwin

477718

478−Windows에서의 `bat`은 기본적으로 Cygwin의 unix 스타일의 경로(`/cygdrive/*`)를 지원하지 않습니다. cygwin 절대경로를 인자로 받았을 때, `bat`은 다음과 같이 오류를 반환합니다. `:The system cannot find the path specified. (os error 3)`

719+Windows에서의 `bat`은 기본적으로 Cygwin의 unix 스타일 경로(`/cygdrive/*`)를

720+지원하지 않습니다.

721+Cygwin 절대 경로를 인자로 받았을 때, `bat`은 다음과 같은 오류를 반환합니다:

722+`The system cannot find the path specified. (os error 3)`

479723

480−이 경우, wrapper를 만들거나 다음 함수를 `.bash_profile`추가하여 문제를 해결하실 수 있습니다 :

724+이는 wrapper를 만들거나 다음 함수를 `.bash_profile`에 추가하여 해결할 수

725+있습니다:

481726

482727```bash

483728bat() {

@@ -493,68 +738,98 @@ bat() {

493738}

494739```

495740

496−## 트러블슈팅

741+## 문제 해결

497742

498743### 터미널과 색상

499744

500−`bat`은 터미널 트루컬러 지원 여부와 상관없이 동작합니다. 하지만, 문법 강조 테마의 색상이 8-bit 컬러에는 최적화 되어 있지 않고 있으며, 24-bit 트루컬러 지원하는 터미널 사용하는 것을 적극 권장합니다.(`terminator`, `konsole`, `iTerm2`, ...). [이 글](https://gist.github.com/XVilka/8346728)에서 24-bit 트루컬러 지원하는 터미널들을 찾아보실 수 있습니다.

745+`bat`은 터미널의 트루컬러 지원 여부와 상관 없이 동작합니다.

746+그러나 대부분 문법 강조 테마의 색상은 8비트 색상에 최적화되어 있지 않습니다.

747+따라서 24비트 트루컬러 지원이 되는 터미널(`terminator`, `konsole`, `iTerm2`,

748+...)을 사용하는 것을 적극 권장합니다.

749+트루컬러를 지원하는 터미널들과 더 자세한 정보는

750+[이 글](https://gist.github.com/XVilka/8346728)에서 찾아보실 수 있습니다.

501751

502−사용하고 있는 터미널에서 `COLORTERM`을 `truecolor` 혹은

503−`24bit`으로 설정 되어있는지 확인하세요. 만약 아니라면, `bat`은 24-bit escape sequence를 지원되는지 여부를 판단 할 수 없습니다. (그리고 8-bit 색상으로 돌아갑니다.)

752+사용하고 있는 트루컬러 터미널에서 `COLORTERM` 변수를 `truecolor` 혹은

753+`24bit`로 설정되어 있는지 확인하세요.

754+그렇지 않을 경우, `bat`은 24비트 확장열(escape sequence)이 지원되는지 여부를

755+판단할 수 없습니다 (그리고 8비트 색상을 사용합니다).

504756

505−### 라인 숫자와 눈금이 잘 보이지 않는 경우

757+### 줄 번호와 격자가 잘 보이지 않는 경우

506758

507−다른 테마를 사용해 보세요. (`bat --list-themes`에서 테마들을 확인해 볼 수 있습니다.) `OneHalfDark` 과 `OneHalfLight` 테마는 눈금과 선의 색을 밝게 합니다.

759+다른 테마를 사용해 보세요 (`bat --list-themes`에서 목록을 볼 수 있습니다).

760+`OneHalfDark`와 `OneHalfLight` 테마는 더 밝은 눈금과 선의 색상을 사용합니다.

508761

509762### 파일 인코딩

510763

511−`bat`은 기본적으로 UTF-8과 UTF-8을 제공합니다. 다른 파일 인코딩의 경우, 자동 감지 되지 않으므로 UTF-8로 먼저 변환해 주어야 합니다. 이렇게 할 때, `iconv`를 사용 할 수 있습니다. 예를 들어, Latin-1 (ISO-8859-1)로 인코딩된 PHP파일이라면 다음과 같이 사용할 수 있습니다.:

764+`bat`은 기본적으로 UTF-8과 UTF-16을 지원합니다.

765+다른 모든 종류의 파일 인코딩에 대해서는, 일반적으로 인코딩을 자동으로 판별하는

766+방법이 없기 때문에 먼저 UTF-8으로 변환해야 할 수 있습니다.

767+이를 위해 `iconv`를 사용할 수 있습니다.

768+예시: Latin-1(ISO-8859-1)로 인코딩된 PHP 파일은 다음과 같이 처리할 수 있습니다:

512769``` bash

513770iconv -f ISO-8859-1 -t UTF-8 my-file.php | bat

514771```

515−참고: `bat`으로 자동 감지가 되지 않는 경우에는 `-l`/`--language` 옵션을 사용할 수도 있습니다.

772+참고: `bat`으로 문법 자동 감지가 되지 않는 경우에는 `-l`/`--language` 옵션을

773+사용할 수 있습니다.

516774

517−## 배포

775+## 개발

518776

519777```bash

520−# Recursive clone to retrieve all submodules

778+# 모든 서브모듈을 받기 위해 재귀적으로 복제하기

521779git clone --recursive https://github.com/sharkdp/bat

522780

523−# Build (debug version)

781+# (디버그 버전) 빌드

524782cd bat

525783cargo build --bins

526784

527−# Run unit tests and integration tests

785+# 단위 테스트와 통합 테스트 실행

528786cargo test

529787

530−# Install (release version)

788+# (배포 버전) 설치

531789cargo install --locked

532790

533−# Build a bat binary with modified syntaxes and themes

791+# 수정된 문법과 테마가 적용된 bat 바이너리 빌드

534792bash assets/create.sh

535793cargo install --locked --force

536794```

537795

796+`bat`의 pretty-printing 기능을 라이브러리로 사용하는 애플리케이션을 만들고

797+싶다면, [API 문서](https://docs.rs/bat/)를 살펴보세요.

798+참고로 `bat`에 라이브러리로써 의존한다면, `regex-onig`나 `regex-fancy`를

799+기능으로 사용해야 합니다.

800+

801+## 기여하기

802+

803+[`CONTRIBUTING.md`](../CONTRIBUTING.md) 가이드를 살펴보세요.

804+

538805## 메인테이너들

539806

540807- [sharkdp](https://github.com/sharkdp)

541808- [eth-p](https://github.com/eth-p)

809+- [keith-hall](https://github.com/keith-hall)

810+- [Enselic](https://github.com/Enselic)

542811

543−## 프로젝트 목표와 대안들

812+## 보안 취약점

544813

545−`bat`은 아래와 같은 목표를 달성하려고 합니다:

814+만약 `bat`의 취약점을 발견하였다면, [David Peter](https://david-peter.de/)에게 메일로 연락주시기 바랍니다.

815+

816+## 프로젝트 목표와 대안들

546817

547−- 아름답고 발전된 문법 강조 기능

548−- Git 연동을 통한 파일 수정 내역 확인

549−- (POSIX)`cat`의 대체제

550−- 사용자 친화적인 CLI 제공

818+`bat`은 다음과 같은 목표를 달성하려고 합니다:

551819

820+- 아름답고 발전된 문법 강조 기능 제공

821+- Git과의 연동을 통한 파일 변경 내용 확인

822+- (POSIX) `cat`의 대체제

823+- 사용자 친화적인 커맨드 라인 인터페이스 제공

552824

553−비슷한 프로그램들을 찾고 있다면, 많은 대안들이 있습니다. 비교는 [이 문서]((doc/alternatives.md))를 참조해주세요.

825+비슷한 프로그램들을 찾고 있다면 많은 대안들이 있습니다.

826+비교는 [이 문서](../doc/alternatives.md)를 참조해 주세요.

554827

555828## 라이센스

557830

558−`bat`는 MIT 라이센스 및 Apache 라이센스 2.0의 조건에 따라 배포됩니다.

831+`bat`는 여러분의 선택에 따라 MIT 라이센스 또는 Apache 라이센스 2.0의 조건에 따라

832+배포됩니다.

559833

560−라이센스 세부사항은 [LICENSE-APACHE](LICENSE-APACHE)와 [LICENSE-MIT](LICENSE-MIT)를 참조하세요.

834+라이센스의 세부사항은 [LICENSE-APACHE](../LICENSE-APACHE)와

835+[LICENSE-MIT](../LICENSE-MIT)를 참조하세요.

doc/README-ru.md+16−13

@@ -1,7 +1,6 @@

11

2− <img src="doc/logo-header.svg" alt="bat - a cat clone with wings">

3− <a href="https://travis-ci.org/sharkdp/bat"><img src="https://travis-ci.org/sharkdp/bat.svg?branch=master" alt="Build Status"></a>

4− <a href="https://ci.appveyor.com/project/sharkdp/bat"><img src="https://ci.appveyor.com/api/projects/status/cptsmtbiwbnr2vhf/branch/master?svg=true"></a>

2+ <img src="logo-header.svg" alt="bat - a cat clone with wings">

3+ <a href="https://github.com/sharkdp/bat/actions?query=workflow%3ACICD"><img src="https://github.com/sharkdp/bat/workflows/CICD/badge.svg" alt="Build Status"></a>

54 <img src="https://img.shields.io/crates/l/bat.svg" alt="license">

65 <a href="https://crates.io/crates/bat"><img src="https://img.shields.io/crates/v/bat.svg?colorB=319e8c" alt="Version info"></a>

76 Клон утилиты cat(1) с поддержкой выделения синтаксиса и Git

@@ -12,8 +11,12 @@

1211 <a href="#как-использовать">Использование</a> •

1312 <a href="#установка">Установка</a> •

1413 <a href="#кастомизация">Кастомизация</a> •

15− <a href="#цели-и-альтернативы">Цели и альтернативы </a> •

16− Перевод [<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>]

14+ <a href="#цели-и-альтернативы">Цели и альтернативы </a>

15+ [<a href="../README.md">English]

16+ [<a href="README-zh.md">中文</a>]

17+ [<a href="README-ja.md">日本語</a>]

18+ [<a href="README-ko.md">한국어</a>]

19+ [Русский]

1720

1821

1922### Выделение синтаксиса

@@ -157,7 +160,7 @@ man 2 select

157160

158161## Установка

159162

160−[![Packaging status](https://repology.org/badge/vertical-allrepos/bat.svg)](https://repology.org/project/bat/versions)

163+[![Packaging status](https://repology.org/badge/vertical-allrepos/bat-cat.svg)](https://repology.org/project/bat-cat/versions)

161164

162165### Ubuntu (с помощью `apt`)

163166*... и другие дистрибутивы основанные на Debian.*

@@ -185,7 +188,7 @@ ln -s /usr/bin/batcat ~/.local/bin/bat

185188[release page](https://github.com/sharkdp/bat/releases) и установить так:

186189

187190```bash

188−sudo dpkg -i bat_0.17.1_amd64.deb # измените архитектуру и версию

191+sudo dpkg -i bat_0.18.3_amd64.deb # измените архитектуру и версию

189192```

190193

191194### Alpine Linux

@@ -341,7 +344,7 @@ ansible-galaxy install aeimer.install_bat

341344

342345### Из исходников

343346

344−Если вы желаете установить `bat` из исходников, вам понадобится Rust 1.40 или выше. После этого используйте `cargo`, чтобы все скомпилировать:

347+Если вы желаете установить `bat` из исходников, вам понадобится Rust 1.51 или выше. После этого используйте `cargo`, чтобы все скомпилировать:

345348

346349```bash

347350cargo install --locked bat

@@ -434,11 +437,11 @@ export BAT_PAGER="less -RF"

434437 `-R`/`--RAW-CONTROL-CHARS`,

435438`-F`/`--quit-if-one-screen` и `-X`/`--no-init`. Последний флаг(`-X`) используется только для `less`, чья версия раньше 530.

436439

437−Флаг `-R` нужен чтобы корректно воспроизвести ANSI цвета. Второй флаг (`-F`) говорит

440+Флаг `-R` нужен чтобы корректно воспроизвести ANSI цвета. Второй флаг (`-F`) говорит

438441`less` чтобы тот сразу же завершился, если размер вывода меньше чем вертикальный размер терминала.

439442Это удобно для небольших файлов, так как вам не надо каждый раз нажимать `q`, чтобы выйти из пейджера. Третий флаг (`-X`) нужен для того, чтобы исправить баг с `--quit-if-one-screen` в старых версиях `less`. К сожалению, это блокирует возможность использования колеса мышки.

440443

441−Если вы хотите все же его включить, вы можете добавить флаг `-R`.

444+Если вы хотите все же его включить, вы можете добавить флаг `-R`.

442445Для `less` новее чем 530 оно должно работать из коробки.

443446

444447### Темная тема

@@ -481,7 +484,7 @@ bat --generate-config-file

481484# Использовать курсив (поддерживается не всеми терминалами)

482485--italic-text=always

483486

484−# Использовать синтаксис C++ для всех .ino файлов

487+# Использовать синтаксис C++ для всех Arduino .ino файлов

485488--map-syntax "*.ino:C++"

486489

487490# Использовать синтаксик Git Ignore для всех файлов .ignore

@@ -499,7 +502,7 @@ Windows поддерживает только очень простой пейд

499502### Цвета

500503

501504Windows 10 поддерживает цвета и в `conhost.exe` (Command Prompt), и в PowerShell начиная с версии Windows

502−[v1511](https://ru.wikipedia.org/wiki/Windows_10#Обновления и поддержка), так же как и в bash. На ранних версиях Windows вы можете использовать

505+[v1511](https://ru.wikipedia.org/wiki/Windows_10#Обновления и поддержка), так же как и в bash. На ранних версиях Windows вы можете использовать

503506[Cmder](http://cmder.net/), в котором есть [ConEmu](https://conemu.github.io/).

504507

505508**Внимание:** Версия `less` в Git и MSYS2 воспроизводит цвета некорректно. Если у вас нет других пейджеров, мы можете отключить использование пейджеров с помощью флага `--paging=never`

@@ -587,7 +590,7 @@ cargo install --locked --force

587590Есть очень много альтернатив `bat`. Смотрите [этот документ](doc/alternatives.md) для сравнения.

588591

589592## Лицензия

591594

592595`bat` распостраняется под лицензями MIT License и Apache License 2.0 (на выбор пользователя).

593596

doc/README-zh.mdnew file+678

@@ -0,0 +1,678 @@

1+

2+ <img src="logo-header.svg" alt="bat - a cat clone with wings">

3+ <a href="https://github.com/sharkdp/bat/actions?query=workflow%3ACICD"><img src="https://github.com/sharkdp/bat/workflows/CICD/badge.svg" alt="Build Status"></a>

4+ <img src="https://img.shields.io/crates/l/bat.svg" alt="license">

5+ <a href="https://crates.io/crates/bat"><img src="https://img.shields.io/crates/v/bat.svg?colorB=319e8c" alt="Version info"></a>

6+ 类似 cat(1)，但带有 git 集成和语法高亮.

7+

9+

10+ <a href="#语法高亮">主要功能</a> •

11+ <a href="#如何使用">使用方法</a> •

12+ <a href="#安装">安装</a> •

13+ <a href="#自定义">自定义</a> •

14+ <a href="#project-goals-and-alternatives">项目目标和替代方案</a>

15+ [<a href="../README.md">English</a>]

16+ [中文]

17+ [<a href="README-ja.md">日本語</a>]

18+ [<a href="README-ko.md">한국어</a>]

19+ [<a href="README-ru.md">Русский</a>]

20+

21+

22+### 语法高亮

23+

24+`bat` 对大部分编程语言和标记语言提供语法高亮：

25+

26+![Syntax highlighting example](https://imgur.com/rGsdnDe.png)

27+

28+### Git 集成

29+

30+`bat` 能从 git 中获取文件的修改并展示在边栏（见下图）：

31+

32+![Git integration example](https://i.imgur.com/2lSW4RE.png)

33+

34+### 不可打印(non-printable)字符可视化

35+

36+添加`-A`/`--show-all`参数可以文件文件中的不可打印字符:

37+

38+![Non-printable character example](https://i.imgur.com/WndGp9H.png)

39+

40+### 自动分页

41+

42+`bat`会在一般情况下将大于屏幕可显示范围的内容输出到分页器(pager, e.g. `less`)。

43+

44+你可以在调用时添加`--paging=never`参数来使`bat`不使用分页器（就像`cat`一样）。如果你想要用为`cat`使用`bat`别名，可以在 shell 配置文件（shell configuration）中添加`alias cat='bat --paging=never'`。

45+

46+#### 智能输出

47+

48+`bat`能够在设置了分页器选项的同时进行管道:wink:。

49+当`bat`检测到当前环境为非可交互终端或管道时（例如使用`bat`并将内容用管道输出到文件），`bat`会像`cat`一样，一次输出文件内容为纯文本且无视`--paging`参数。

50+

51+## 如何使用

52+

53+在终端中查看一个文件

54+

55+```bash

56+> bat README.md

57+```

58+

59+一次性展示多个文件

60+

61+```bash

62+> bat src/*.rs

63+```

64+

65+从`stdin`读入流，自动为内容添加语法高亮（前提是输入内容的语言可以被正确识别，通常根据内容第一行的 shebang 标记，形如`#!bin/sh`）

66+

67+```bash

68+> curl -s https://sh.rustup.rs | bat

69+```

70+

71+显式指定`stdin`输入的语言

72+

73+```bash

74+> yaml2json .travis.yml | json_pp | bat -l json

75+```

76+

77+显示不可打印字符

78+

79+```bash

80+> bat -A /etc/hosts

81+```

82+

83+与`cat`的兼容性

84+

85+```bash

86+bat > note.md # 创建一个空文件

87+

88+bat header.md content.md footer.md > document.md

89+

90+bat -n main.rs # 只显示行号

91+

92+bat f - g # 输出 f，接着是标准输入流，最后 g

93+```

94+

95+### 第三方工具交互

96+

97+#### `fzf`

98+

99+你可以使用`bat`作为`fzf`的预览器。这需要在`bat`后添加`--color=always`选项，以及`--line-range` 选项来限制大文件的加载次数。

100+

101+```bash

102+fzf --preview 'bat --color=always --style=numbers --line-range=:500 {}'

103+```

104+

105+更多信息请参阅[`fzf`的说明](https://github.com/junegunn/fzf#preview-window)。

106+

107+#### `find` 或 `fd`

108+

109+你可以使用`find`的`-exec`选项来用`bat`预览搜索结果：

110+

111+```bash

112+find … -exec bat {} +

113+```

114+

115+亦或者在用`fd`时添加`-X`/`--exec-batch`选项：

116+

117+```bash

118+fd … -X bat

119+```

120+

121+#### `ripgrep`

122+

123+`bat`也能用`batgrep`来显示`ripgrep`的搜索结果。

124+

125+```bash

126+batgrep needle src/

127+```

128+

129+#### `tail -f`

130+

131+当与`tail -f`一起使用，`bat`可以持续监视文件内容并为其添加语法高亮。

132+

133+```bash

134+tail -f /var/log/pacman.log | bat --paging=never -l log

135+```

136+

137+注意：这项功能需要在关闭分页时使用，同时要手动指定输入的内容语法（通过`-l log`）。

138+

139+#### `git`

140+

141+`bat`也能直接接受来自`git show`的输出并为其添加语法高亮（当然也需要手动指定语法）：

142+

143+```bash

144+git show v0.6.0:src/main.rs | bat -l rs

145+```

146+

147+#### `git diff`

148+

149+`bat`也可以和`git diff`一起使用：

150+

151+```bash

152+batdiff() {

153+ git diff --name-only --diff-filter=d | xargs bat --diff

154+}

155+```

156+

157+该功能也作为一个独立工具提供，你可以在[`bat-extras`](https://github.com/eth-p/bat-extras)中找到`batdiff`。

158+

159+如果你想了解更多 git 和 diff 的信息，参阅[`delta`](https://github.com/dandavison/delta)。

160+

161+#### `xclip`

162+

163+当需要拷贝文件内容时，行号以及 git 标记会影响输出，此时可以使用`-p`/`--plain`参数来把纯文本传递给`xclip`。

164+

165+```bash

166+bat main.cpp | xclip

167+```

168+

169+`bat`会检测输出是否是管道重定向来决定是否使用纯文本输出。

170+

171+#### `man`

172+

173+`bat`也能给`man`的输出上色。这需要设置`MANPAGER`环境变量：

174+

175+```bash

176+export MANPAGER="sh -c 'col -bx | bat -l man -p'"

177+man 2 select

178+```

179+

180+（如果你使用的是 Debian 或者 Ubuntu，使用`batcat`替换`bat`）

181+

182+如果你遇到格式化问题，设置`MANROFFOPT="-c"`也许会有帮助。

183+

184+`batman`能提供类似功能——作为一个独立的命令。

185+

186+注意：[man page 语法](assets/syntaxes/02_Extra/Manpage.sublime-syntax) 还需要完善。在使用特定的`man`实现时该功能[无法正常工作](https://github.com/sharkdp/bat/issues/1145)。

187+

188+#### `prettier` / `shfmt` / `rustfmt`

189+

190+`prettybat`脚本能够格式化代码并用`bat`输出。

191+

192+## 安装

193+

194+[![Packaging status](https://repology.org/badge/vertical-allrepos/bat-cat.svg)](https://repology.org/project/bat-cat/versions)

195+

196+### Ubuntu (使用 `apt`)

197+

198+*... 以及其他基于 Debian的发行版.*

199+

200+`bat` 要求的版本： [Ubuntu 高于 20.04 ("Focal")](https://packages.ubuntu.com/search?keywords=bat&exact=1) 和 [Debian 高于 August 2021 (Debian 11 - "Bullseye")](https://packages.debian.org/bullseye/bat).

201+

202+当你的发行版满足条件那么直接在终端运执行：

203+

204+```bash

205+sudo apt install bat

206+```

207+

208+重要：如果你通过这种方法安装`bat`，请留意你所安装的可执行文件是否为`batcat`（由[其他包的可执行文件名冲突](https://github.com/sharkdp/bat/issues/982)造成）。你可以创建一个`bat -> batcat`的符号链接(symlink)或别名来避免因为可执行文件不同带来的问题并与其他发行版保持一致性。

209+

210+```bash

211+mkdir -p ~/.local/bin

212+ln -s /usr/bin/batcat ~/.local/bin/bat

213+```

214+

215+### Ubuntu (使用`.deb`包)

216+

217+*... 以及其他基于 Debian的发行版.*

218+

219+如果你无法使用上一种方法安装，或需要用最新版的`bat`，你可以从[release 页面](https://github.com/sharkdp/bat/releases)下载最新的`.deb`包并通过下述方法安装：

220+

221+```bash

222+sudo dpkg -i bat_0.18.3_amd64.deb # adapt version number and architecture

223+```

224+

225+### Alpine Linux

226+

227+你可以用下面下列命令从官方源中安装[`bat 包`](https://pkgs.alpinelinux.org/packages?name=bat)：

228+

229+```bash

230+apk add bat

231+```

232+

233+### Arch Linux

234+

235+你可以用下面下列命令从官方源中安装[`bat`包](https://www.archlinux.org/packages/community/x86_64/bat/)：

236+

237+```bash

238+pacman -S bat

239+```

240+

241+### Fedora

242+

243+你可以使用下列命令从官方[Fedora Modular](https://docs.fedoraproject.org/en-US/modularity/using-modules/)仓库安装[`bat` 包](https://koji.fedoraproject.org/koji/packageinfo?packageID=27506)：

244+

245+```bash

246+dnf install bat

247+```

248+

249+### Funtoo Linux

250+

251+你可以从 dev-kit 中安装[`bat` 包](https://github.com/funtoo/dev-kit/tree/1.4-release/sys-apps/bat)：

252+

253+```bash

254+emerge sys-apps/bat

255+```

256+

257+### Gentoo Linux

258+

259+你可以使用下列命令从官方源中安装 [`bat` 包](https://packages.gentoo.org/packages/sys-apps/bat)：

260+

261+

262+```bash

263+emerge sys-apps/bat

264+```

265+

266+### Void Linux

267+

268+你可以用 xbps-install 安装`bat`：

269+

270+```bash

271+xbps-install -S bat

272+```

273+

274+### Termux:

275+

276+你可以用 pkg 安装`bat：

277+

278+```bash

279+pkg install bat

280+```

281+

282+### FreeBSD

283+

284+你可以用 pkg 来安装一份预编译的[`bat` 包](https://www.freshports.org/textproc/bat)：

285+

286+```bash

287+pkg install bat

288+```

289+

290+或从 FreeBSD ports 自己编译一份：

291+

292+```bash

293+cd /usr/ports/textproc/bat

294+make install

295+```

296+

297+### OpenBSD

298+

299+你可以用`pkg——add`安装`bat`包

300+

301+```bash

302+pkg_add bat

303+```

304+

305+### 通过 nix

306+

307+你可以用[nix 包管理器](https://nixos.org/nix)安装`bat`：

308+

309+```bash

310+nix-env -i bat

311+```

312+

313+### openSUSE

314+

315+你可以用 zypper 安装`bat`：

316+

317+```bash

318+zypper install bat

319+```

320+

321+### 通过 snap

322+

323+目前还没有推荐的 snap 包可用。可以使用其他现存的包但不会受到官方支持且可能会遇到[问题](https://github.com/sharkdp/bat/issues/1519)。

324+

325+### macOS (或 Linux) 通过 Homebrew

326+

327+你可以用 [Homebrew on MacOS](https://formulae.brew.sh/formula/bat) 或者 [Homebrew on Linux](https://formulae.brew.sh/formula-linux/bat) 安装`bat`：

328+

329+```bash

330+brew install bat

331+```

332+

333+### macOS 通过 MacPorts

334+

335+或用 [MacPorts](https://ports.macports.org/port/bat/summary) 安装`bat`：

336+

337+```bash

338+port install bat

339+```

340+

341+### Windows

342+

343+在 Windows 上具有多种安装`bat`的方法。若你已完成安装，记得看看 ["在 Windows 上使用`bat`"](#在-Windows-中使用-bat) 。

344+

345+#### 前置条件

346+

347+你必须已安装 [Visual C++ Redistributable](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads) 包。

348+

349+#### 使用 Chocolatey

350+

351+你可以用[Chocolatey](https://chocolatey.org/packages/Bat) 安装`bat`：

352+

353+```bash

354+choco install bat

355+```

356+

357+#### 使用 Scoop

358+

359+你可以用 [scoop](https://scoop.sh/) 安装`bat`：

360+

361+```bash

362+scoop install bat

363+```

364+

365+#### 使用预编译二进制版本

366+

367+直接从 [Release 发布页](https://github.com/sharkdp/bat/releases) 下载已经编译好的二进制包，前提是你安装了 [Visual C++ Redistributable](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads) 包。

368+

369+### 使用二进制版本

370+

371+在 [Release 发布页](https://github.com/sharkdp/bat/releases) 中可以找到为多种架构构建的`bat`版本和静态编译的二进制文件（文件名带有`musl`）。

372+

373+### 从源码编译

374+

375+如果你想要自己构建`bat`，那么你需要安装有高于1.51版本的 Rust。

376+

377+使用以下命令编译。

378+

379+```bash

380+cargo install --locked bat

381+```

382+

383+注意：man page或 shell 自动补全所需要的额外文件无法通过该方法安装。但你可以在`cargo`的生成目录找到这些文件（`build`目录下）。

384+

385+## 自定义

386+

387+### 语法高亮主题

388+

389+使用 `bat --list-themes` 一份语法高亮主题的清单，然后用`--theme=TwoDark`来指定主题为`TwoDark`，也可以通过设置`BAT_THEME`环境变量来选定主题。把`export BAT_THEME="TwoDark"`添加到 shell 的启动脚本（shell startup file）来取得永久效果。或者使用`bat`的[配置文件](#c配置文件)

390+

391+若想要查看所有主题在一个文件上的显示效果可以用一下命令（需要安装`fzf`）：

392+

393+```bash

394+bat --list-themes | fzf --preview="bat --theme={} --color=always /path/to/file"

395+```

396+

397+`bat`在默认情况下能够在黑色主题背景下获得较好的效果，如果你的终端使用亮色背景，可以试试`GitHub`或`OneHalfLight`。想要添加自定义主题可以参考[添加主题](#添加主题)。

398+

399+### 8-bit 主题

400+

401+`bat` 自带三个 [8-bit 色彩](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors) 主题：

402+

403+- `ansi` 适应于大部分终端。它使用 3-bit 色彩：黑红绿黄蓝洋红靛青白。

404+- `base16`专为 [base16](https://github.com/chriskempson/base16) 终端设计。它使用 4-bit 色彩（带有亮度的 3-bit 色彩）。根据 [base16 styling guidelines](https://github.com/chriskempson/base16/blob/master/styling.md) 制作。

405+- `base16-25`专为 [base16-shell](https://github.com/chriskempson/base16-shell) 设计。它把部分亮色替换为 8-bit 色彩。请不要直接使用该主题，除非你清楚你的256色终端是否使用 base16-shell。

406+

407+尽管这些主题具有诸多限制，但具有一些 truecolor 主题不具有的三个优点：

408+

409+- 享有最佳兼容性。并不是所有终端工具都支持高于 3-bit 的色彩。

410+- 适应终端主题。

411+- 视觉上和其他的终端工具更协调。

412+

413+### 输出样式

414+

415+你可以用`--style`参数来控制`bat`输出的样式。使用`--style=numbers,chanegs`可以只开启 Git 修改和行号显示而不添加其他内容。`BAT_STYLE`环境变量具有相同功能。

416+

417+### 添加新的语言和语法

418+

419+当现有的`bat`不支持某个语言或语法时你可以自己添加。

420+

421+`bat`使用`syntect`库来支持语法高亮，该库使用 [Sublime Text `.sublime-syntax` 语法文件](https://www.sublimetext.com/docs/3/syntax.html)和主题。而后者中的大部分可以在 [Package Control](https://packagecontrol.io/) 找到。

422+

423+当你找到一份语法文件，按照下列方法：

424+

425+1. 创建包含语法描述文件的目录：

426+

427+ ```bash

428+ mkdir -p "$(bat --config-dir)/syntaxes"

429+ cd "$(bat --config-dir)/syntaxes"

430+

431+ # Put new '.sublime-syntax' language definition files

432+ # in this folder (or its subdirectories), for example:

433+ git clone https://github.com/tellnobody1/sublime-purescript-syntax

434+ ```

435+

436+2. 调用下面指令把文件转换为二进制缓存：

437+

438+ ```bash

439+ bat cache --build

440+ ```

441+

442+3. 最后用`bat --list-languages`来检查新的语法是否被成功导入。如果想要回滚到最初状态，执行：

443+

444+ ```bash

445+ bat cache --clear

446+ ```

447+

448+4. 如果你觉得`bat`有必要自带该语法支持，请在阅读[指导](doc/assets.md)后向仓库提交 [Syntax Request](https://github.com/sharkdp/bat/issues/new?labels=syntax-request&template=syntax_request.md)。

449+

450+### 添加主题

451+

452+类似添加语法支持，第一步也是创建一个带有语法高亮的目录

453+

454+```bash

455+mkdir -p "$(bat --config-dir)/themes"

456+cd "$(bat --config-dir)/themes"

457+

458+# 下载一个主题

459+git clone https://github.com/greggb/sublime-snazzy

460+

461+# 更新二进制缓存

462+bat cache --build

463+```

464+

465+然后用`bat --list-themes`检查添加是否成功。

466+

467+### 添加或修改文件关联

468+

469+你可以用`--map-syntax`参数添加或修改文件名模板。它需要一个类似`pattern:syntax`的参数来指定，其中`pattern`是 glob 文件匹配模板，`syntax`则是支持的语法的完整名（使用`bat --list-languages`来查看获取一份清单）。

470+

471+注意：方便起见，你可能需要把参数添加到配置文件，而不是每次都在命令行中传递该参数。

472+

473+以下展示了把“INI”关联到具有`.conf`扩展名的文件

474+

475+```bash

476+--map-syntax='*.conf:INI'

477+```

478+

479+把`.ignore`文件与“Git Ignore”关联

480+

481+```bash

482+--map-syntax='.ignore:Git Ignore'

483+```

484+

485+把`/etc/apache2`内的`.conf`文件关联到“Apache Conf”语法（`bat`已默认绑定）

486+

487+```bash

488+--map-syntax='/etc/apache2/**/*.conf:Apache Conf'

489+```

490+

491+### 使用自定义分页器

492+

493+`bat`默认使用`PAGER`环境变量定义的分页器，如果没有定义则使用`less`。`bat`提供了`BAT_PAGER`环境变量来专为`bat`选择分页器（优先级高于`PAGER`）。

494+

495+注意：当`PAGER`设置为`more`或`most`时，`bat`会使用`less`来代替以确保能提供色彩支持。

496+

497+```bash

498+export BAT_PAGER="less -RF"

499+```

500+

501+除了使用环境变量来改变`bat`使用的的分页器，也可以在配置文件中提供`--pager`参数。

502+

503+注意：`bat`会把部分命令行参数直接传递给分页器：`-R`/`--RAW-CONTROL-CHARS`,`-F`/`--quit-if-one-screen`以及`-X`/`--no-init`（该参数仅适用于高于530版本的`less`）。其中`-R` 参数需要在解释 ANSI 标准颜色时起作用。`-F`则指示`less`在输出内容的垂直尺寸小于终端尺寸时立即退出。当文件内容可以在一个屏幕里完全显示时，就不需要按`q`键退出阅读模式，很方便就是了。`-X`则能修复`-F`在`less`的老版本中的一些bug（代价是不支持鼠标滚轮，但可以用`-R`来取消`quit-if-one-screen`功能。）。

504+

505+### 缩进

506+

507+`bat` 使用四个空格宽的制表符，而不受分页器影响，同时也可以用`--tabs`参数来自定义。

508+

509+注意：通过其他方法针对分页器的制表符设置不会生效（例如通过`bat`的`--pager`参数传递或`less`使用的`LESS`环境变量）。因为在输出提交给分页器之前，内容中的制表符就已经被`bat`替换为了特定长度的空格以避免由于边栏导致的缩进问题。你可以用给`bat`传递`--tabs=0`参数来取消该设定并让分页器自己处理制表符。

510+

511+### 暗色模式

512+

513+如果你用的 macOS 处于暗色模式，你可以为`bat`启用基于系统主题的主题。如下所示操作会让`bat`在系统处于亮色模式时加载`GitHub`主题和暗色模式时加载`default`主题。

514+

515+```bash

516+alias cat="bat --theme=\$(defaults read -globalDomain AppleInterfaceStyle &> /dev/null && echo default || echo GitHub)"

517+```

518+

519+## 配置文件

520+

521+```bash

522+bat --config-file

523+```

524+

525+你也可以用`BAT_CONFIG_PATH`来为`bat`指定自定义位置的配置文件：

526+

527+```bash

528+export BAT_CONFIG_PATH="/path/to/bat.conf"

529+```

530+

531+使用`--generate-config-file`参数调用`bat`会在指定位置生成一份默认的`bat`配置文件：

532+

533+```bash

534+bat --generate-config-file

535+```

536+

537+### 格式

538+

539+配置文件其实是一份按行分割的命令行参数列表。你可以用`bat --help`来查看所有可用的参数和适用的值。配置文件中`#`打头的行会被视为注释而不生效。

540+

541+以下是一份示例：

542+

543+```bash

544+# 设置主题为 TwoDark

545+--theme="TwoDark"

546+

547+# 显示行号和 Git 修改信息，但没有边框

548+--style="numbers,changes,header"

549+

550+# 在终端中以斜体输出文本（不是所有终端都支持）

551+--italic-text=always

552+

553+# 使用 C++ 语法来给 Ardiuno 的 .ino 文件提供高亮

554+--map-syntax "*.ino:C++"

555+```

556+

557+## 在 Windows 中使用 `bat`

558+

559+`bat` 在 Windows 上开箱即用，除了部分功能需要额外配置。

560+

561+### 前置条件

562+

563+你需要先安装 [Visual C++ Redistributable](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads) 包。

564+

565+### 分页

566+

567+Windows 只有一个提供有限功能的分页器，你可以从[这里下载](http://www.greenwoodsoftware.com/less/download.html)或用 [Chocolatey 安装](https://chocolatey.org/packages/Less) Windows 版本的`less`。第一种方法需要你把它所在目录加入`PATH`环境变量或[定义分页器变量](#使用自定义分页器)

568+

569+### 色彩

570+

571+Windows 10 从 [v1511](https://en.wikipedia.org/wiki/Windows_10_version_history#Version_1511_(November_Update)) 开始 shell（`conhost.exe`，命令提示符或 Powershell）原生支持色彩。在早些版本的 Windows 中你可以用第三方终端如 [Cmder](http://cmder.net/) （使用[ConEmu](https://conemu.github.io/)）。

572+

573+注意：Git 和 MSYS 版本的 `less` 没法正确在 Windows 表达色彩。如果你没有安装其他分页器，你可以直接用`--paging=never`或设置`BAT_PAGER`为空字符串来关闭分页功能。

574+

575+### Cygwin

576+

577+Windows 上的`bat`原生不支持 Cygwin' unix-style 路径（`/cygdrive/*`）。当传递一个绝对 cygwin 路径作为参数值时，`bat`会产生`The system cannot find the path specified. (os error 3)`的错误。你可以`.bash_profile`文件中添加以下函数来解决这个问题。

578+

579+```bash

580+bat() {

581+ local index

582+ local args=("$@")

583+ for index in $(seq 0 ${#args[@]}) ; do

584+ case "${args[index]}" in

585+ -*) continue;;

586+ *) [ -e "${args[index]}" ] && args[index]="$(cygpath --windows "${args[index]}")";;

587+ esac

588+ done

589+ command bat "${args[@]}"

590+}

591+```

592+

593+## 疑难解答

594+

595+### 输出内容含糊不清

596+

597+当输入文件包含颜色代码和其他 ANSI 转义符号时，`bat`会产生错误的语法高亮和文本，导致输出看起来令人无法理解。当你需要输出该文件时，请使用`--color=never --wrap=never`参数来关闭上色和文字包裹。

598+

599+### 终端与色彩

600+

601+`bat`会区分支持 truecolor 和不支持 truecolor 的终端。但是大部分语法高亮主题都是用了没有为 8-bit 色彩支持的颜色，因此强烈推荐使用一个支持 24-bit 色彩的终端（`terminator`，`konsole`，`iTerm2`...），或使用一个 [8-bit 主题](#8-bit-主题)来限制一些颜色。查看[这篇文章使用自定义分页器](https://gist.github.com/XVilka/8346728)了解更多支持 truecolor 的终端。你需要定义`COLORTERM`变量为`truecolor`或`24bit`来确保`bat`能够识别终端的对颜色的支持，否则会使用 8 bit 模式。

602+

603+### 行号和边框很难看清

604+

605+试试其他主题，说不定能有所改善（用`bat --list-themes`查看主题列表）。

606+

607+### 文件编码

608+

609+`bat`原生支持 UTF-8 和 UTF-16。至于其他文件你可能需要在使用`bat`之前先把编码转换到UTF-8。

610+

611+这里展示了使用`iconv`来把 Latin-1(ISO-8859-1) 编码的 PHP 文件转换到 UTF-8：

612+

613+```bash

614+iconv -f ISO-8859-1 -t UTF-8 my-file.php | bat

615+```

616+

617+注意：当`bat`无法识别语言时你可能会需要`-l`/`--language`参数。

618+

619+## Development

620+

621+```bash

622+# Recursive clone to retrieve all submodules

623+git clone --recursive https://github.com/sharkdp/bat

624+

625+# Build (debug version)

626+cd bat

627+cargo build --bins

628+

629+# Run unit tests and integration tests

630+cargo test

631+

632+# Install (release version)

633+cargo install --path . --locked

634+

635+# Build a bat binary with modified syntaxes and themes

636+bash assets/create.sh

637+cargo install --path . --locked --force

638+```

639+

640+If you want to build an application that uses `bat`s pretty-printing

641+features as a library, check out the [the API documentation](https://docs.rs/bat/).

642+Note that you have to use either `regex-onig` or `regex-fancy` as a feature

643+when you depend on `bat` as a library.

644+

645+## Contributing

646+

647+Take a look at the [`CONTRIBUTING.md`](CONTRIBUTING.md) guide.

648+

649+## Maintainers

650+

651+- [sharkdp](https://github.com/sharkdp)

652+- [eth-p](https://github.com/eth-p)

653+- [keith-hall](https://github.com/keith-hall)

654+- [Enselic](https://github.com/Enselic)

655+

656+## Security vulnerabilities

657+

658+Please contact [David Peter](https://david-peter.de/) via email if you want to report a vulnerability in `bat`.

659+

660+## Project goals and alternatives

661+

662+`bat` tries to achieve the following goals:

663+

664+- Provide beautiful, advanced syntax highlighting

665+- Integrate with Git to show file modifications

666+- Be a drop-in replacement for (POSIX) `cat`

667+- Offer a user-friendly command-line interface

668+

669+There are a lot of alternatives, if you are looking for similar programs. See

670+[this document](doc/alternatives.md) for a comparison.

671+

672+## License

673+

675+

676+`bat` is made available under the terms of either the MIT License or the Apache License 2.0, at your option.

677+

678+See the [LICENSE-APACHE](LICENSE-APACHE) and [LICENSE-MIT](LICENSE-MIT) files for license details.

doc/alternatives.md+40−1

@@ -9,7 +9,7 @@ if you are not looking for a program like `bat`, this comparison might not be fo

99| Drop-in `cat` replacement | :heavy_check_mark: [*](https://github.com/sharkdp/bat/issues/134) | :x: | :x: | (:heavy_check_mark:) | :x: | :x: [*](https://github.com/rstacruz/hicat/issues/6) | :x: | :x: |

1010| Git integration | :heavy_check_mark: | :x: | :x: | :x: | :x: | :x: | :x: | :x: |

1111| Automatic paging | :heavy_check_mark: | :x: | :x: | :x: | :x: | :heavy_check_mark: | :x: | :x: |

12−| Languages (circa) | 110 | 300 | 200 | 7 | 80 | 130 | 30 | 130 |

12+| Languages (circa) | 150 | 300 | 200 | 7 | 80 | 130 | 30 | 130 |

1313| Extensible (languages, themes) | :heavy_check_mark: | (:heavy_check_mark:) | (:heavy_check_mark:) | :x: | (:heavy_check_mark:) | :x: | :x: | :x: |

1515| Execution time [ms] (`jquery-3.3.1.js`) | 624 | 789 | 400 | 80 | 300 | 316 | 157 | 695 |

@@ -22,3 +22,42 @@ request.

2222Some other alternatives that are also related, but not yet included in the table:

2323- [lesspipe](https://github.com/wofr06/lesspipe)

2424- [vimpager](https://github.com/rkitover/vimpager)

25+

26+## Benchmarks

27+

28+The benchmarks above have been created with this script:

29+```bash

30+#!/usr/bin/env bash

31+

32+cd "$(dirname "${BASH_SOURCE[0]}")" || exit

33+

34+if ! command -v hyperfine > /dev/null 2>&1; then

35+ echo "'hyperfine' does not seem to be installed."

36+ echo "You can get it here: https://github.com/sharkdp/hyperfine"

37+ exit 1

38+fi

39+

40+SRC="test-src/jquery-3.3.1.js"

41+

42+

43+cmd_bat="bat --style=full --color=always --paging=never '$SRC'"

44+cmd_bat_simple="bat --plain --wrap=never --tabs=0 --color=always --paging=never '$SRC'"

45+cmd_pygmentize="pygmentize -g '$SRC'"

46+cmd_highlight="highlight -O truecolor '$SRC'"

47+cmd_ccat="ccat --color=always '$SRC'"

48+cmd_source_highlight="source-highlight --failsafe --infer-lang -f esc -i '$SRC'"

49+cmd_hicat="hicat '$SRC'"

50+cmd_coderay="coderay '$SRC'"

51+cmd_rouge="rougify '$SRC'"

52+

53+hyperfine --warmup 3 \

54+ "$cmd_bat" \

55+ "$cmd_bat_simple" \

56+ "$cmd_pygmentize" \

57+ "$cmd_highlight" \

58+ "$cmd_ccat" \

59+ "$cmd_source_highlight" \

60+ "$cmd_hicat" \

61+ "$cmd_coderay" \

62+ "$cmd_rouge" \

63+```

doc/assets.md+45−6

@@ -9,22 +9,60 @@ in the `.sublime-syntax` format.

99**Important:** Before proceeding, verify that the syntax you wish to add meets the [criteria for inclusion](#Criteria-for-inclusion-of-new-syntaxes).

1010

11111. Find a Sublime Text syntax for the given language, preferably in a separate Git repository

12− which can be included as a submodule (under `assets/syntaxes`).

12+ which can be included as a submodule (under `assets/syntaxes`) using

13+ `git submodule add <https github link> ./assets/syntaxes/02_Extra/<repo name>`, replacing

14+ the contents of the angle brackets as appropriate.

1315

14162. If the Sublime Text syntax is only available as a `.tmLanguage` file, open the file in

1517 Sublime Text and convert it to a `.sublime-syntax` file via *Tools* -> *Developer* ->

1618 *New Syntax from XXX.tmLanguage...*. Save the new file in the `assets/syntaxes` folder.

1719

18203. Run the `assets/create.sh` script. It calls `bat cache --build` to parse all available

19− `.sublime-syntax` files and serialize them to a `syntaxes.bin` file (in this folder).

21+ `.sublime-syntax` files and serialize them to a `syntaxes.bin` file.

2022

21234. Re-compile `bat`. At compilation time, the `syntaxes.bin` file will be stored inside the

2224 `bat` binary.

2325

24265. Use `bat --list-languages` to check if the new languages are available.

2527

26−6. If you send a pull request with your changes, please do *not* include the changed `syntaxes.bin`

27− file. A new binary cache file will be created once before every new release of `bat`.

28+6. Add a syntax test for the new language. See [below](#Syntax-tests) for details.

29+

30+7. If you send a pull request with your changes, please do *not* include the changed `syntaxes.bin`

31+ file. A new binary cache file will be created once before every new release of `bat`. This

32+ avoids bloating the repository size unnecessarily.

33+

34+### Syntax tests

35+

36+`bat` has a set of syntax highlighting regression tests in `tests/syntax-tests`. The main idea is

37+make sure that we do not run into issues we had in the past where either (1) syntax highlighting

38+for some language is suddenly not working anymore or (2) `bat` suddenly crashes for some input (due

39+to `regex` incompatibilities between `syntect` and Sublime Text).

40+

41+In order to add a new test file, please follow these steps (let's take "Ruby" as an example):

42+

43+1. Make sure that you are running the **latest version of `bat`** and that `bat` is available on

44+ the path. If you are creating a syntax test for a new builtin syntax (see above), make sure that

45+ your version of `bat` already has the new syntax builtin.

46+2. Find an example Ruby source file or write one yourself. If possible, the file should aim to be

47+ "comprehensive" (i.e. include a lot of the possible syntax), but this is not strictly necessary.

48+ A simple file is better than none at all. Also, the files shouldn't be gigantic.

49+3. Save the file in `tests/syntax-tests/source/Ruby` (adapt for your language). The file name could

50+ be `test.rb` (adapt extension) but can also be adapted if that is necessary in order for `bat` to

51+ highlight it correctly (e.g. `Makefile`).

52+4. If you have copied the file from somewhere else, please make sure that the file *may* be copied

53+ under the respective license and that the license is compatible with `bat`s license. If it

54+ requires attribution, please add a `LICENSE.md` in the same folder with a text like this:

55+ ```

56+ The `test.rb` file has been added from [enter source here] under the following license:

57+

58+ [add license text here]

59+ ```

60+5. Go to `tests/syntax-tests` and run the `update.sh` Bash script. A new file should be generated

61+ in the `highlighted` folder (e.g. `highlighted/Ruby/test.rb`).

62+6. Use `cat` or `bat --language=txt` to display the content of this file and make sure that the

63+ syntax highlighting looks correct.

64+7. `git add` the new files in the `source` folder as well as the autogenerated files in the

65+ `highlighted` folder.

2866

2967### Troubleshooting

3068

@@ -33,7 +71,7 @@ themes (`bat cache --clear`).

3371

3472## Criteria for inclusion of new syntaxes

3573

36−* More than 10,000 downloads on packagecontrol.io/

74+* More than 10,000 downloads at [Package Control](https://packagecontrol.io)

3775

3876### Manual modifications

3977

@@ -44,7 +82,7 @@ The following files have been manually modified after converting from a `.tmLang

4482* `INI.sublime-syntax` => added `.hgrc`, `hgrc`, and `desktop` file types and support for comments after section headers

4583* `Org mode.sublime-syntax` => removed `task` file type.

4684* `SML.sublime_syntax` => removed `ml` file type.

47−* `Robot.sublime_syntax` => changed name to "Robot Framework"

85+* `Robot.sublime_syntax` => changed name to "Robot Framework", added `.resource` extension

4886

4987### Non-submodule additions

5088

@@ -59,3 +97,4 @@ The following files have been manually modified after converting from a `.tmLang

5997 https://github.com/seanjames777/SML-Language-Definition/blob/master/sml.tmLanguage

6098* `Cabal.sublime_syntax` has been added manually from

6199 https://github.com/SublimeHaskell/SublimeHaskell/ - we don't want to include the whole submodule because it includes other syntaxes ("Haskell improved") as well.

100+* `Lean.sublime-syntax` has been added manually from https://github.com/leanprover/vscode-lean/blob/master/syntaxes/lean.json via conversion.

doc/release-checklist.mdnew file+73

@@ -0,0 +1,73 @@

1+# Release checklist

3+## Version bump

5+- [ ] Update version in `Cargo.toml`. Run `cargo build` to update `Cargo.lock`.

6+ Make sure to `git add` the `Cargo.lock` changes as well.

7+- [ ] Find the current min. supported Rust version by running

8+ `grep '^\s*MIN_SUPPORTED_RUST_VERSION' .github/workflows/CICD.yml`.

9+- [ ] Update the version and the min. supported Rust version in `README.md` and

10+ `doc/README-*.md`. Check with

11+ `git grep -i -e 'rust.*1\.' -e '1\..*rust' | grep README | grep -v tests/`.

12+- [ ] Update `CHANGELOG.md`. Introduce a section for the new release.

13+

14+## Update syntaxes and themes (build assets)

15+

16+- [ ] Install the latest master version (`cargo clean && cargo install --locked -f --path .`) and make

17+ sure that it is available on the `PATH` (`bat --version` should show the

18+ new version).

19+- [ ] Run `assets/create.sh` and check in the binary asset files.

20+

21+## Documentation

22+

23+- [ ] Review `-h`, `--help`, and the `man` page. All of these are shown in

24+ the output of the CI job called *Documentation*, so look there.

25+ The CI workflow corresponding to the tip of the master branch is a good place to look.

26+

27+## Pre-release checks

28+

29+- [ ] Push all changes and wait for CI to succeed (before continuing with the

30+ next section).

31+- [ ] Optional: manually test the new features and command-line options. To do

32+ this, install the latest `bat` version again (to include the new syntaxes

33+ and themes).

34+- [ ] Run `cargo publish --dry-run` to make sure that it will

35+ succeed later (after creating the GitHub release).

36+

37+## Release

38+

39+- [ ] Create a tag and push it: `git tag vX.Y.Z; git push origin tag vX.Y.Z`.

40+ This will trigger the deployment via GitHub Actions.

41+ REMINDER: If your `origin` is a fork, don't forget to push to e.g. `upstream` instead!

42+- [ ] Go to https://github.com/sharkdp/bat/releases/new to create the new

43+ release. Select the new tag and also use it as the release title. For the

44+ release notes, copy the corresponding section from `CHANGELOG.md` and

45+ possibly add additional remarks for package maintainers.

46+ Publish the release.

47+- [ ] Check if the binary deployment works (archives and Debian packages should

48+ appear when the CI run for the Git tag has finished).

49+- [ ] Publish to crates.io by running `cargo publish` in a *clean* repository.

50+ The safest way to do this is to clone a fresh copy.

51+

52+## Post-release

53+

54+- [ ] Prepare a new "unreleased" section at the top of `CHANGELOG.md`.

55+ Put this at the top:

56+

57+```

58+# unreleased

59+

60+## Features

61+

62+## Bugfixes

63+

64+## Other

65+

66+## Syntaxes

67+

68+## Themes

69+

70+## `bat` as a library

71+

72+

73+```

doc/sponsors.mdnew file+14

@@ -0,0 +1,14 @@

1+## Sponsors

3+`bat` development is sponsored by many individuals and companies. Thank you very much!

5+Please note, that being sponsored does not affect the individuality of the `bat`

6+project or affect the maintainers' actions in any way.

7+We remain impartial and continue to assess pull requests solely on merit - the

8+features added, bugs solved, and effect on the overall complexity of the code.

9+No issue will have a different priority based on sponsorship status of the

10+reporter.

11+

12+Contributions from anybody are most welcomed, please see our [`CONTRIBUTING.md`](../CONTRIBUTING.md) guide.

13+

14+If you want to see our biggest sponsors, check the top of [`README.md`](../README.md#sponsors).

doc/sponsors/workos-logo-white-bg.svgnew file+11

@@ -0,0 +1,11 @@

1+<svg width="1354" height="420" viewBox="0 0 1354 420" fill="none" xmlns="http://www.w3.org/2000/svg">

2+<rect width="1354" height="420" rx="20" fill="white"/>

3+<path d="M434.751 133.122H466.637L489.595 227.729C493.852 245.585 494.697 256.219 494.697 256.219H495.128C495.128 256.219 496.61 245.808 500.867 227.729L522.757 133.122H558.9L582.066 227.729C586.53 246.223 587.598 256.219 587.598 256.219H588.236C588.236 256.219 588.666 246.223 592.907 227.729L615.02 133.122H646.907L606.523 288.313H571.017L546.576 194.344C541.474 173.936 541.044 164.801 541.044 164.801H540.614C540.614 164.801 540.183 173.936 535.512 194.344L512.553 288.313H475.996L434.751 133.122Z" fill="black"/>

4+<path d="M641.583 231.934C641.583 196.428 664.541 173.47 699.202 173.47C733.639 173.47 756.597 196.428 756.597 231.934C756.597 267.647 733.639 290.828 699.202 290.828C664.557 290.812 641.583 267.647 641.583 231.934ZM726.832 231.934C726.832 208.976 715.783 195.998 699.202 195.998C681.346 195.998 671.349 210.458 671.349 231.934C671.349 255.323 682.398 268.284 699.202 268.284C717.058 268.284 726.832 253.824 726.832 231.934Z" fill="black"/>

5+<path d="M770.836 175.21H799.103V196.048H799.741C804.635 185.207 816.322 174.365 836.299 174.365C839.695 174.365 841.831 174.796 843.314 175.21V203.478H842.469C842.469 203.478 839.918 202.633 832.903 202.633C811.013 202.633 799.103 215.594 799.103 239.828V288.295H770.836V175.21Z" fill="black"/>

6+<path d="M856.5 133.122H884.767V182.865C884.767 212.2 884.336 217.509 884.336 217.509H884.767L926.857 175.212H962.139L912.843 224.11L970.031 288.313H936.646L895.401 241.536L884.767 251.946V288.297H856.5V133.122Z" fill="black"/>

7+<path d="M970.444 211.285C970.444 163.455 1000.21 131.569 1044.85 131.569C1089.49 131.569 1119.26 163.455 1119.26 211.285C1119.26 259.114 1089.49 291.001 1044.85 291.001C1000.21 291.001 970.444 259.114 970.444 211.285ZM1088.42 211.285C1088.42 178.761 1071 156.855 1044.84 156.855C1018.67 156.855 1001.26 178.761 1001.26 211.285C1001.26 243.809 1018.69 265.715 1044.84 265.715C1070.98 265.715 1088.42 243.809 1088.42 211.285Z" fill="black"/>

8+<path d="M1130.08 236.656H1162.4C1162.4 254.943 1174.95 265.146 1194.08 265.146C1210.23 265.146 1221.29 257.063 1221.29 245.584C1221.29 232.622 1212.79 229.21 1185.79 223.901C1161.12 219.007 1134.98 210.716 1134.98 178.399C1134.98 151.408 1157.93 131 1193.01 131C1229.57 131 1252.11 150.132 1252.11 179.037H1219.79C1219.79 165.007 1208.95 156.286 1193.01 156.286C1176.86 156.286 1166.86 164.146 1166.86 175.625C1166.86 187.742 1173.88 192.413 1195.56 196.878C1227.65 203.685 1254.02 207.288 1254.02 243.001C1254.02 271.3 1229.36 290.432 1193.01 290.432C1156.02 290.432 1130.08 268.957 1130.08 236.656Z" fill="black"/>

9+<path d="M100 210C100 214.824 101.269 219.647 103.723 223.793L148.231 300.878C152.8 308.747 159.739 315.178 168.369 318.055C185.377 323.724 202.977 316.447 211.354 301.893L222.1 283.278L179.708 210L224.47 132.408L235.216 113.792C238.431 108.208 242.747 103.638 247.824 100H243.17H178.777C166.677 100 155.508 106.431 149.5 116.923L103.723 196.208C101.269 200.354 100 205.177 100 210Z" fill="#6363F1"/>

10+<path d="M353.847 210C353.847 205.177 352.578 200.353 350.124 196.207L305.024 118.107C296.647 103.638 279.047 96.3608 262.039 101.945C253.409 104.822 246.47 111.253 241.901 119.122L231.747 136.638L274.139 210L229.378 287.592L218.632 306.208C215.416 311.708 211.101 316.362 206.024 320H210.678H275.07C287.17 320 298.34 313.569 304.347 303.077L350.124 223.792C352.578 219.646 353.847 214.823 353.847 210Z" fill="#6363F1"/>

11+</svg>

rustfmt.tomlnew file+1

@@ -0,0 +1 @@

1+# Defaults are used

src/assets.rs+410−241

@@ -1,203 +1,255 @@

1−use std::collections::BTreeMap;

21use std::ffi::OsStr;

3−use std::fs::{self, File};

4−use std::io::BufReader;

2+use std::fs;

53use std::path::Path;

7−use syntect::dumps::{dump_to_file, from_binary, from_reader};

8−use syntect::highlighting::{Theme, ThemeSet};

9−use syntect::parsing::{SyntaxReference, SyntaxSet, SyntaxSetBuilder};

5+use once_cell::unsync::OnceCell;

7+use syntect::highlighting::Theme;

8+use syntect::parsing::{SyntaxReference, SyntaxSet};

109

1110use path_abs::PathAbs;

1211

13−use crate::assets_metadata::AssetsMetadata;

1412use crate::error::*;

15−use crate::input::{InputReader, OpenedInput, OpenedInputKind};

16−use crate::syntax_mapping::{MappingTarget, SyntaxMapping};

13+use crate::input::{InputReader, OpenedInput};

14+use crate::syntax_mapping::ignored_suffixes::IgnoredSuffixes;

15+use crate::syntax_mapping::MappingTarget;

16+use crate::{bat_warning, SyntaxMapping};

17+

18+use lazy_theme_set::LazyThemeSet;

19+

20+use serialized_syntax_set::*;

21+

22+#[cfg(feature = "build-assets")]

23+pub use crate::assets::build_assets::*;

24+

25+pub(crate) mod assets_metadata;

26+#[cfg(feature = "build-assets")]

27+mod build_assets;

28+mod lazy_theme_set;

29+mod serialized_syntax_set;

1730

1831#[derive(Debug)]

1932pub struct HighlightingAssets {

20− pub(crate) syntax_set: SyntaxSet,

21− pub(crate) theme_set: ThemeSet,

33+ syntax_set_cell: OnceCell<SyntaxSet>,

34+ serialized_syntax_set: SerializedSyntaxSet,

35+

36+ theme_set: LazyThemeSet,

2237 fallback_theme: Option<&'static str>,

2338}

2439

25−impl HighlightingAssets {

26− pub fn default_theme() -> &'static str {

27− "Monokai Extended"

28− }

29−

30− pub fn from_files(source_dir: &Path, include_integrated_assets: bool) -> Result<Self> {

31− let mut theme_set = if include_integrated_assets {

32− Self::get_integrated_themeset()

33− } else {

34− ThemeSet {

35− themes: BTreeMap::new(),

36− }

37− };

40+#[derive(Debug)]

41+pub struct SyntaxReferenceInSet<'a> {

42+ pub syntax: &'a SyntaxReference,

43+ pub syntax_set: &'a SyntaxSet,

44+}

3845

39− let theme_dir = source_dir.join("themes");

46+/// Lazy-loaded syntaxes are already compressed, and we don't want to compress

47+/// already compressed data.

48+pub(crate) const COMPRESS_SYNTAXES: bool = false;

4049

41− let res = theme_set.add_from_folder(&theme_dir);

42− if res.is_err() {

43− println!(

44− "No themes were found in '{}', using the default set",

45− theme_dir.to_string_lossy()

46− );

47− }

50+/// We don't want to compress our [LazyThemeSet] since the lazy-loaded themes

51+/// within it are already compressed, and compressing another time just makes

52+/// performance suffer

53+pub(crate) const COMPRESS_THEMES: bool = false;

4854

49− let mut syntax_set_builder = if !include_integrated_assets {

50− let mut builder = SyntaxSetBuilder::new();

51− builder.add_plain_text_syntax();

52− builder

53− } else {

54− Self::get_integrated_syntaxset().into_builder()

55− };

55+/// Compress for size of ~40 kB instead of ~200 kB without much difference in

56+/// performance due to lazy-loading

57+pub(crate) const COMPRESS_LAZY_THEMES: bool = true;

5658

57− let syntax_dir = source_dir.join("syntaxes");

58− if syntax_dir.exists() {

59− syntax_set_builder.add_from_folder(syntax_dir, true)?;

60− } else {

61− println!(

62− "No syntaxes were found in '{}', using the default set.",

63− syntax_dir.to_string_lossy()

64− );

65− }

59+/// Compress for size of ~10 kB instead of ~120 kB

60+pub(crate) const COMPRESS_ACKNOWLEDGEMENTS: bool = true;

6661

67− Ok(HighlightingAssets {

68− syntax_set: syntax_set_builder.build(),

62+impl HighlightingAssets {

63+ fn new(serialized_syntax_set: SerializedSyntaxSet, theme_set: LazyThemeSet) -> Self {

64+ HighlightingAssets {

65+ syntax_set_cell: OnceCell::new(),

66+ serialized_syntax_set,

6967 theme_set,

7068 fallback_theme: None,

71− })

69+ }

7270 }

7371

74− pub fn from_cache(cache_path: &Path) -> Result<Self> {

75− let syntax_set_path = cache_path.join("syntaxes.bin");

76− let theme_set_path = cache_path.join("themes.bin");

77−

78− let syntax_set_file = File::open(&syntax_set_path).chain_err(|| {

79− format!(

80− "Could not load cached syntax set '{}'",

81− syntax_set_path.to_string_lossy()

82− )

83− })?;

84− let syntax_set: SyntaxSet = from_reader(BufReader::new(syntax_set_file))

85− .chain_err(|| "Could not parse cached syntax set")?;

86−

87− let theme_set_file = File::open(&theme_set_path).chain_err(|| {

88− format!(

89− "Could not load cached theme set '{}'",

90− theme_set_path.to_string_lossy()

91− )

92− })?;

93− let theme_set: ThemeSet = from_reader(BufReader::new(theme_set_file))

94− .chain_err(|| "Could not parse cached theme set")?;

72+ /// The default theme.

73+ ///

74+ /// ### Windows and Linux

75+ ///

76+ /// Windows and most Linux distributions has a dark terminal theme by

77+ /// default. On these platforms, this function always returns a theme that

78+ /// looks good on a dark background.

79+ ///

80+ /// ### macOS

81+ ///

82+ /// On macOS the default terminal background is light, but it is common that

83+ /// Dark Mode is active, which makes the terminal background dark. On this

84+ /// platform, the default theme depends on

85+ /// ```bash

86+ /// defaults read -globalDomain AppleInterfaceStyle

87+ /// ````

88+ /// To avoid the overhead of the check on macOS, simply specify a theme

89+ /// explicitly via `--theme`, `BAT_THEME`, or `~/.config/bat`.

90+ ///

91+ /// See <https://github.com/sharkdp/bat/issues/1746> and

92+ /// <https://github.com/sharkdp/bat/issues/1928> for more context.

93+ pub fn default_theme() -> &'static str {

94+ #[cfg(not(target_os = "macos"))]

95+ {

96+ Self::default_dark_theme()

97+ }

98+ #[cfg(target_os = "macos")]

99+ {

100+ if macos_dark_mode_active() {

101+ Self::default_dark_theme()

102+ } else {

103+ Self::default_light_theme()

104+ }

105+ }

106+ }

95107

96− Ok(HighlightingAssets {

97− syntax_set,

98− theme_set,

99− fallback_theme: None,

100− })

108+ /**

109+ * The default theme that looks good on a dark background.

110+ */

111+ fn default_dark_theme() -> &'static str {

112+ "Monokai Extended"

101113 }

102114

103− fn get_integrated_syntaxset() -> SyntaxSet {

104− from_binary(include_bytes!("../assets/syntaxes.bin"))

115+ /**

116+ * The default theme that looks good on a light background.

117+ */

118+ #[cfg(target_os = "macos")]

119+ fn default_light_theme() -> &'static str {

120+ "Monokai Extended Light"

105121 }

106122

107− fn get_integrated_themeset() -> ThemeSet {

108− from_binary(include_bytes!("../assets/themes.bin"))

123+ pub fn from_cache(cache_path: &Path) -> Result<Self> {

124+ Ok(HighlightingAssets::new(

125+ SerializedSyntaxSet::FromFile(cache_path.join("syntaxes.bin")),

126+ asset_from_cache(&cache_path.join("themes.bin"), "theme set", COMPRESS_THEMES)?,

127+ ))

109128 }

110129

111130 pub fn from_binary() -> Self {

112− let syntax_set = Self::get_integrated_syntaxset();

113− let theme_set = Self::get_integrated_themeset();

114−

115− HighlightingAssets {

116− syntax_set,

117− theme_set,

118− fallback_theme: None,

119− }

131+ HighlightingAssets::new(

132+ SerializedSyntaxSet::FromBinary(get_serialized_integrated_syntaxset()),

133+ get_integrated_themeset(),

134+ )

120135 }

121136

122− pub fn save_to_cache(&self, target_dir: &Path, current_version: &str) -> Result<()> {

123− let _ = fs::create_dir_all(target_dir);

124− let theme_set_path = target_dir.join("themes.bin");

125− let syntax_set_path = target_dir.join("syntaxes.bin");

126−

127− print!(

128− "Writing theme set to {} ... ",

129− theme_set_path.to_string_lossy()

130− );

131− dump_to_file(&self.theme_set, &theme_set_path).chain_err(|| {

132− format!(

133− "Could not save theme set to {}",

134− theme_set_path.to_string_lossy()

135− )

136− })?;

137− println!("okay");

138−

139− print!(

140− "Writing syntax set to {} ... ",

141− syntax_set_path.to_string_lossy()

142− );

143− dump_to_file(&self.syntax_set, &syntax_set_path).chain_err(|| {

144− format!(

145− "Could not save syntax set to {}",

146− syntax_set_path.to_string_lossy()

147− )

148− })?;

149− println!("okay");

137+ pub fn set_fallback_theme(&mut self, theme: &'static str) {

138+ self.fallback_theme = Some(theme);

139+ }

150140

151− print!(

152− "Writing metadata to folder {} ... ",

153− target_dir.to_string_lossy()

154− );

155− AssetsMetadata::new(current_version).save_to_folder(target_dir)?;

156− println!("okay");

141+ /// Return the collection of syntect syntax definitions.

142+ pub fn get_syntax_set(&self) -> Result<&SyntaxSet> {

143+ self.syntax_set_cell

144+ .get_or_try_init(|| self.serialized_syntax_set.deserialize())

145+ }

157146

158− Ok(())

147+ /// Use [Self::get_syntaxes] instead

148+ #[deprecated]

149+ pub fn syntaxes(&self) -> &[SyntaxReference] {

150+ self.get_syntax_set()

151+ .expect(".syntaxes() is deprecated, use .get_syntaxes() instead")

152+ .syntaxes()

159153 }

160154

161− pub fn set_fallback_theme(&mut self, theme: &'static str) {

162− self.fallback_theme = Some(theme);

155+ pub fn get_syntaxes(&self) -> Result<&[SyntaxReference]> {

156+ Ok(self.get_syntax_set()?.syntaxes())

163157 }

164158

165− pub fn syntaxes(&self) -> &[SyntaxReference] {

166− self.syntax_set.syntaxes()

159+ fn get_theme_set(&self) -> &LazyThemeSet {

160+ &self.theme_set

167161 }

168162

169163 pub fn themes(&self) -> impl Iterator<Item = &str> {

170− self.theme_set.themes.keys().map(|s| s.as_ref())

164+ self.get_theme_set().themes()

171165 }

172166

167+ /// Use [Self::get_syntax_for_path] instead

168+ #[deprecated]

173169 pub fn syntax_for_file_name(

174170 &self,

175171 file_name: impl AsRef<Path>,

176172 mapping: &SyntaxMapping,

177173 ) -> Option<&SyntaxReference> {

178− let file_name = file_name.as_ref();

179− match mapping.get_syntax_for(file_name) {

180− Some(MappingTarget::MapToUnknown) => None,

181− Some(MappingTarget::MapTo(syntax_name)) => {

182− self.syntax_set.find_syntax_by_name(syntax_name)

174+ self.get_syntax_for_path(file_name, mapping)

175+ .ok()

176+ .map(|syntax_in_set| syntax_in_set.syntax)

177+ }

178+

179+ /// Detect the syntax based on, in order:

180+ /// 1. Syntax mappings with [MappingTarget::MapTo] and [MappingTarget::MapToUnknown]

181+ /// (e.g. `/etc/profile` -> `Bourne Again Shell (bash)`)

182+ /// 2. The file name (e.g. `Dockerfile`)

183+ /// 3. Syntax mappings with [MappingTarget::MapExtensionToUnknown]

184+ /// (e.g. `*.conf`)

185+ /// 4. The file name extension (e.g. `.rs`)

186+ ///

187+ /// When detecting syntax based on syntax mappings, the full path is taken

188+ /// into account. When detecting syntax based on file name, no regard is

189+ /// taken to the path of the file. Only the file name itself matters. When

190+ /// detecting syntax based on file name extension, only the file name

191+ /// extension itself matters.

192+ ///

193+ /// Returns [Error::UndetectedSyntax] if it was not possible detect syntax

194+ /// based on path/file name/extension (or if the path was mapped to

195+ /// [MappingTarget::MapToUnknown] or [MappingTarget::MapExtensionToUnknown]).

196+ /// In this case it is appropriate to fall back to other methods to detect

197+ /// syntax. Such as using the contents of the first line of the file.

198+ ///

199+ /// Returns [Error::UnknownSyntax] if a syntax mapping exist, but the mapped

200+ /// syntax does not exist.

201+ pub fn get_syntax_for_path(

202+ &self,

203+ path: impl AsRef<Path>,

204+ mapping: &SyntaxMapping,

205+ ) -> Result<SyntaxReferenceInSet> {

206+ let path = path.as_ref();

207+

208+ let syntax_match = mapping.get_syntax_for(path);

209+

210+ if let Some(MappingTarget::MapToUnknown) = syntax_match {

211+ return Err(Error::UndetectedSyntax(path.to_string_lossy().into()));

212+ }

213+

214+ if let Some(MappingTarget::MapTo(syntax_name)) = syntax_match {

215+ return self

216+ .find_syntax_by_name(syntax_name)?

217+ .ok_or_else(|| Error::UnknownSyntax(syntax_name.to_owned()));

218+ }

219+

220+ let file_name = path.file_name().unwrap_or_default();

221+

222+ match (

223+ self.get_syntax_for_file_name(file_name, &mapping.ignored_suffixes)?,

224+ syntax_match,

225+ ) {

226+ (Some(syntax), _) => Ok(syntax),

227+

228+ (_, Some(MappingTarget::MapExtensionToUnknown)) => {

229+ Err(Error::UndetectedSyntax(path.to_string_lossy().into()))

183230 }

184− None => self.get_extension_syntax(file_name.as_os_str()),

231+

232+ _ => self

233+ .get_syntax_for_file_extension(file_name, &mapping.ignored_suffixes)?

234+ .ok_or_else(|| Error::UndetectedSyntax(path.to_string_lossy().into())),

185235 }

186236 }

187237

188− pub(crate) fn get_theme(&self, theme: &str) -> &Theme {

189− match self.theme_set.themes.get(theme) {

238+ /// Look up a syntect theme by name.

239+ pub fn get_theme(&self, theme: &str) -> &Theme {

240+ match self.get_theme_set().get(theme) {

190241 Some(theme) => theme,

191242 None => {

192− if theme != "" {

193− use ansi_term::Colour::Yellow;

194− eprintln!(

195− "{}: Unknown theme '{}', using default.",

196− Yellow.paint("[bat warning]"),

197− theme

198− );

243+ if theme == "ansi-light" || theme == "ansi-dark" {

244+ bat_warning!("Theme '{}' is deprecated, using 'ansi' instead.", theme);

245+ return self.get_theme("ansi");

199246 }

200− &self.theme_set.themes[self.fallback_theme.unwrap_or_else(|| Self::default_theme())]

247+ if !theme.is_empty() {

248+ bat_warning!("Unknown theme '{}', using default.", theme)

249+ }

250+ self.get_theme_set()

251+ .get(self.fallback_theme.unwrap_or_else(Self::default_theme))

252+ .expect("something is very wrong if the default theme is missing")

201253 }

202254 }

203255 }

@@ -207,78 +259,153 @@ impl HighlightingAssets {

207259 language: Option<&str>,

208260 input: &mut OpenedInput,

209261 mapping: &SyntaxMapping,

210− ) -> Result<&SyntaxReference> {

262+ ) -> Result<SyntaxReferenceInSet> {

211263 if let Some(language) = language {

212− self.syntax_set

264+ let syntax_set = self.get_syntax_set()?;

265+ return syntax_set

213266 .find_syntax_by_token(language)

214− .ok_or_else(|| ErrorKind::UnknownSyntax(language.to_owned()).into())

267+ .map(|syntax| SyntaxReferenceInSet { syntax, syntax_set })

268+ .ok_or_else(|| Error::UnknownSyntax(language.to_owned()));

269+ }

270+

271+ let path = input.path();

272+ let path_syntax = if let Some(path) = path {

273+ self.get_syntax_for_path(

274+ PathAbs::new(path).map_or_else(|_| path.to_owned(), |p| p.as_path().to_path_buf()),

275+ mapping,

276+ )

215277 } else {

216− let line_syntax = self.get_first_line_syntax(&mut input.reader);

217−

218− // Get the path of the file:

219− // If this was set by the metadata, that will take priority.

220− // If it wasn't, it will use the real file path (if available).

221− let path_str =

222− input

223− .metadata

224− .user_provided_name

225− .as_ref()

226− .or_else(|| match input.kind {

227− OpenedInputKind::OrdinaryFile(ref path) => Some(path),

228− _ => None,

229− });

230−

231− if let Some(path_str) = path_str {

232− // If a path was provided, we try and detect the syntax based on extension mappings.

233− let path = Path::new(path_str);

234− let absolute_path = PathAbs::new(path)

235− .ok()

236− .map(|p| p.as_path().to_path_buf())

237− .unwrap_or_else(|| path.to_owned());

238−

239− match mapping.get_syntax_for(absolute_path) {

240− Some(MappingTarget::MapToUnknown) => line_syntax.ok_or_else(|| {

241− ErrorKind::UndetectedSyntax(path.to_string_lossy().into()).into()

242− }),

243−

244− Some(MappingTarget::MapTo(syntax_name)) => self

245− .syntax_set

246− .find_syntax_by_name(syntax_name)

247− .ok_or_else(|| ErrorKind::UnknownSyntax(syntax_name.to_owned()).into()),

248−

249− None => {

250− let file_name = path.file_name().unwrap_or_default();

251− self.get_extension_syntax(file_name)

252− .or(line_syntax)

253− .ok_or_else(|| {

254− ErrorKind::UndetectedSyntax(path.to_string_lossy().into()).into()

255− })

256− }

257− }

258− } else {

259− // If a path wasn't provided, we fall back to the detect first-line syntax.

260− line_syntax.ok_or_else(|| ErrorKind::UndetectedSyntax("[unknown]".into()).into())

261− }

278+ Err(Error::UndetectedSyntax("[unknown]".into()))

279+ };

280+

281+ match path_syntax {

282+ // If a path wasn't provided, or if path based syntax detection

283+ // above failed, we fall back to first-line syntax detection.

284+ Err(Error::UndetectedSyntax(path)) => self

285+ .get_first_line_syntax(&mut input.reader)?

286+ .ok_or(Error::UndetectedSyntax(path)),

287+ _ => path_syntax,

262288 }

263289 }

264290

265− fn get_extension_syntax(&self, file_name: &OsStr) -> Option<&SyntaxReference> {

266− self.syntax_set

267− .find_syntax_by_extension(file_name.to_str().unwrap_or_default())

268− .or_else(|| {

269− self.syntax_set.find_syntax_by_extension(

270− Path::new(file_name)

271− .extension()

272− .and_then(|x| x.to_str())

273− .unwrap_or_default(),

274− )

275− })

291+ pub(crate) fn find_syntax_by_name(

292+ &self,

293+ syntax_name: &str,

294+ ) -> Result<Option<SyntaxReferenceInSet>> {

295+ let syntax_set = self.get_syntax_set()?;

296+ Ok(syntax_set

297+ .find_syntax_by_name(syntax_name)

298+ .map(|syntax| SyntaxReferenceInSet { syntax, syntax_set }))

299+ }

300+

301+ fn find_syntax_by_extension(&self, e: Option<&OsStr>) -> Result<Option<SyntaxReferenceInSet>> {

302+ let syntax_set = self.get_syntax_set()?;

303+ let extension = e.and_then(|x| x.to_str()).unwrap_or_default();

304+ Ok(syntax_set

305+ .find_syntax_by_extension(extension)

306+ .map(|syntax| SyntaxReferenceInSet { syntax, syntax_set }))

307+ }

308+

309+ fn get_syntax_for_file_name(

310+ &self,

311+ file_name: &OsStr,

312+ ignored_suffixes: &IgnoredSuffixes,

313+ ) -> Result<Option<SyntaxReferenceInSet>> {

314+ let mut syntax = self.find_syntax_by_extension(Some(file_name))?;

315+ if syntax.is_none() {

316+ syntax =

317+ ignored_suffixes.try_with_stripped_suffix(file_name, |stripped_file_name| {

318+ // Note: recursion

319+ self.get_syntax_for_file_name(stripped_file_name, ignored_suffixes)

320+ })?;

321+ }

322+ Ok(syntax)

276323 }

277324

278− fn get_first_line_syntax(&self, reader: &mut InputReader) -> Option<&SyntaxReference> {

279− String::from_utf8(reader.first_line.clone())

325+ fn get_syntax_for_file_extension(

326+ &self,

327+ file_name: &OsStr,

328+ ignored_suffixes: &IgnoredSuffixes,

329+ ) -> Result<Option<SyntaxReferenceInSet>> {

330+ let mut syntax = self.find_syntax_by_extension(Path::new(file_name).extension())?;

331+ if syntax.is_none() {

332+ syntax =

333+ ignored_suffixes.try_with_stripped_suffix(file_name, |stripped_file_name| {

334+ // Note: recursion

335+ self.get_syntax_for_file_extension(stripped_file_name, ignored_suffixes)

336+ })?;

337+ }

338+ Ok(syntax)

339+ }

340+

341+ fn get_first_line_syntax(

342+ &self,

343+ reader: &mut InputReader,

344+ ) -> Result<Option<SyntaxReferenceInSet>> {

345+ let syntax_set = self.get_syntax_set()?;

346+ Ok(String::from_utf8(reader.first_line.clone())

280347 .ok()

281− .and_then(|l| self.syntax_set.find_syntax_by_first_line(&l))

348+ .and_then(|l| syntax_set.find_syntax_by_first_line(&l))

349+ .map(|syntax| SyntaxReferenceInSet { syntax, syntax_set }))

350+ }

351+}

352+

353+pub(crate) fn get_serialized_integrated_syntaxset() -> &'static [u8] {

354+ include_bytes!("../assets/syntaxes.bin")

355+}

356+

357+pub(crate) fn get_integrated_themeset() -> LazyThemeSet {

358+ from_binary(include_bytes!("../assets/themes.bin"), COMPRESS_THEMES)

359+}

360+

361+pub fn get_acknowledgements() -> String {

362+ from_binary(

363+ include_bytes!("../assets/acknowledgements.bin"),

364+ COMPRESS_ACKNOWLEDGEMENTS,

365+ )

366+}

367+

368+pub(crate) fn from_binary<T: serde::de::DeserializeOwned>(v: &[u8], compressed: bool) -> T {

369+ asset_from_contents(v, "n/a", compressed)

370+ .expect("data integrated in binary is never faulty, but make sure `compressed` is in sync!")

371+}

372+

373+fn asset_from_contents<T: serde::de::DeserializeOwned>(

374+ contents: &[u8],

375+ description: &str,

376+ compressed: bool,

377+) -> Result<T> {

378+ if compressed {

379+ bincode::deserialize_from(flate2::read::ZlibDecoder::new(contents))

380+ } else {

381+ bincode::deserialize_from(contents)

382+ }

383+ .map_err(|_| format!("Could not parse {}", description).into())

384+}

385+

386+fn asset_from_cache<T: serde::de::DeserializeOwned>(

387+ path: &Path,

388+ description: &str,

389+ compressed: bool,

390+) -> Result<T> {

391+ let contents = fs::read(path).map_err(|_| {

392+ format!(

393+ "Could not load cached {} '{}'",

394+ description,

395+ path.to_string_lossy()

396+ )

397+ })?;

398+ asset_from_contents(&contents[..], description, compressed)

399+ .map_err(|_| format!("Could not parse cached {}", description).into())

400+}

401+

402+#[cfg(target_os = "macos")]

403+fn macos_dark_mode_active() -> bool {

404+ let mut defaults_cmd = std::process::Command::new("defaults");

405+ defaults_cmd.args(&["read", "-globalDomain", "AppleInterfaceStyle"]);

406+ match defaults_cmd.output() {

407+ Ok(output) => output.stdout == b"Dark\n",

408+ Err(_) => true,

282409 }

283410}

284411

@@ -289,8 +416,8 @@ mod tests {

289416 use std::ffi::OsStr;

290417

291418 use std::fs::File;

292− use std::io::Write;

293− use tempdir::TempDir;

419+ use std::io::{BufReader, Write};

420+ use tempfile::TempDir;

294421

295422 use crate::input::Input;

296423

@@ -305,11 +432,22 @@ mod tests {

305432 SyntaxDetectionTest {

306433 assets: HighlightingAssets::from_binary(),

307434 syntax_mapping: SyntaxMapping::builtin(),

308− temp_dir: TempDir::new("bat_syntax_detection_tests")

309− .expect("creation of temporary directory"),

435+ temp_dir: TempDir::new().expect("creation of temporary directory"),

310436 }

311437 }

312438

439+ fn get_syntax_name(

440+ &self,

441+ language: Option<&str>,

442+ input: &mut OpenedInput,

443+ mapping: &SyntaxMapping,

444+ ) -> String {

445+ self.assets

446+ .get_syntax(language, input, mapping)

447+ .map(|syntax_in_set| syntax_in_set.syntax.name.clone())

448+ .unwrap_or_else(|_| "!no syntax!".to_owned())

449+ }

450+

313451 fn syntax_for_real_file_with_content_os(

314452 &self,

315453 file_name: &OsStr,

@@ -321,29 +459,21 @@ mod tests {

321459 writeln!(temp_file, "{}", first_line).unwrap();

322460 }

323461

324− let input = Input::ordinary_file(file_path.as_os_str());

462+ let input = Input::ordinary_file(&file_path);

325463 let dummy_stdin: &[u8] = &[];

326− let mut opened_input = input.open(dummy_stdin).unwrap();

464+ let mut opened_input = input.open(dummy_stdin, None).unwrap();

327465

328− self.assets

329− .get_syntax(None, &mut opened_input, &self.syntax_mapping)

330− .unwrap_or_else(|_| self.assets.syntax_set.find_syntax_plain_text())

331− .name

332− .clone()

466+ self.get_syntax_name(None, &mut opened_input, &self.syntax_mapping)

333467 }

334468

335469 fn syntax_for_file_with_content_os(&self, file_name: &OsStr, first_line: &str) -> String {

336470 let file_path = self.temp_dir.path().join(file_name);

337471 let input = Input::from_reader(Box::new(BufReader::new(first_line.as_bytes())))

338− .with_name(Some(file_path.as_os_str()));

472+ .with_name(Some(&file_path));

339473 let dummy_stdin: &[u8] = &[];

340− let mut opened_input = input.open(dummy_stdin).unwrap();

474+ let mut opened_input = input.open(dummy_stdin, None).unwrap();

341475

342− self.assets

343− .get_syntax(None, &mut opened_input, &self.syntax_mapping)

344− .unwrap_or_else(|_| self.assets.syntax_set.find_syntax_plain_text())

345− .name

346− .clone()

476+ self.get_syntax_name(None, &mut opened_input, &self.syntax_mapping)

347477 }

348478

349479 #[cfg(unix)]

@@ -360,14 +490,10 @@ mod tests {

360490 }

361491

362492 fn syntax_for_stdin_with_content(&self, file_name: &str, content: &[u8]) -> String {

363− let input = Input::stdin().with_name(Some(OsStr::new(file_name)));

364− let mut opened_input = input.open(content).unwrap();

493+ let input = Input::stdin().with_name(Some(file_name));

494+ let mut opened_input = input.open(content, None).unwrap();

365495

366− self.assets

367− .get_syntax(None, &mut opened_input, &self.syntax_mapping)

368− .unwrap_or_else(|_| self.assets.syntax_set.find_syntax_plain_text())

369− .name

370− .clone()

496+ self.get_syntax_name(None, &mut opened_input, &self.syntax_mapping)

371497 }

372498

373499 fn syntax_is_same_for_inputkinds(&self, file_name: &str, content: &str) -> bool {

@@ -444,6 +570,7 @@ mod tests {

444570 assert_eq!(test.syntax_for_file("test.sass"), "Sass");

445571 assert_eq!(test.syntax_for_file("test.js"), "JavaScript (Babel)");

446572 assert_eq!(test.syntax_for_file("test.fs"), "F#");

573+ assert_eq!(test.syntax_for_file("test.v"), "Verilog");

447574 }

448575

449576 #[test]

@@ -476,13 +603,58 @@ mod tests {

476603 }

477604

478605 #[test]

479− fn syntax_detection_is_case_sensitive() {

606+ fn syntax_detection_with_extension_mapping_to_unknown() {

480607 let mut test = SyntaxDetectionTest::new();

481608

482− assert_ne!(test.syntax_for_file("README.MD"), "Markdown");

609+ // Normally, a CMakeLists.txt file shall use the CMake syntax, even if it is

610+ // a bash script in disguise

611+ assert_eq!(

612+ test.syntax_for_file_with_content("CMakeLists.txt", "#!/bin/bash"),

613+ "CMake"

614+ );

615+

616+ // Other .txt files shall use the Plain Text syntax

617+ assert_eq!(

618+ test.syntax_for_file_with_content("some-other.txt", "#!/bin/bash"),

619+ "Plain Text"

620+ );

621+

622+ // If we setup MapExtensionToUnknown on *.txt, the match on the full

623+ // file name of "CMakeLists.txt" shall have higher prio, and CMake shall

624+ // still be used for it

625+ test.syntax_mapping

626+ .insert("*.txt", MappingTarget::MapExtensionToUnknown)

627+ .ok();

628+ assert_eq!(

629+ test.syntax_for_file_with_content("CMakeLists.txt", "#!/bin/bash"),

630+ "CMake"

631+ );

632+

633+ // However, for *other* files with a .txt extension, first-line fallback

634+ // shall now be used

635+ assert_eq!(

636+ test.syntax_for_file_with_content("some-other.txt", "#!/bin/bash"),

637+ "Bourne Again Shell (bash)"

638+ );

639+ }

640+

641+ #[test]

642+ fn syntax_detection_is_case_insensitive() {

643+ let mut test = SyntaxDetectionTest::new();

644+

645+ assert_eq!(test.syntax_for_file("README.md"), "Markdown");

646+ assert_eq!(test.syntax_for_file("README.mD"), "Markdown");

647+ assert_eq!(test.syntax_for_file("README.Md"), "Markdown");

648+ assert_eq!(test.syntax_for_file("README.MD"), "Markdown");

649+

650+ // Adding a mapping for "MD" in addition to "md" should not break the mapping

483651 test.syntax_mapping

484652 .insert("*.MD", MappingTarget::MapTo("Markdown"))

485653 .ok();

654+

655+ assert_eq!(test.syntax_for_file("README.md"), "Markdown");

656+ assert_eq!(test.syntax_for_file("README.mD"), "Markdown");

657+ assert_eq!(test.syntax_for_file("README.Md"), "Markdown");

486658 assert_eq!(test.syntax_for_file("README.MD"), "Markdown");

487659 }

488660

@@ -515,15 +687,12 @@ mod tests {

515687 .expect("creation of directory succeeds");

516688 symlink(&file_path, &file_path_symlink).expect("creation of symbolic link succeeds");

517689

518− let input = Input::ordinary_file(file_path_symlink.as_os_str());

690+ let input = Input::ordinary_file(&file_path_symlink);

519691 let dummy_stdin: &[u8] = &[];

520− let mut opened_input = input.open(dummy_stdin).unwrap();

692+ let mut opened_input = input.open(dummy_stdin, None).unwrap();

521693

522694 assert_eq!(

523− test.assets

524− .get_syntax(None, &mut opened_input, &test.syntax_mapping)

525− .unwrap_or_else(|_| test.assets.syntax_set.find_syntax_plain_text())

526− .name,

695+ test.get_syntax_name(None, &mut opened_input, &test.syntax_mapping),

527696 "SSH Config"

528697 );

529698 }

src/assets_metadata.rs → src/assets/assets_metadata.rsrenamed+10−9

@@ -16,6 +16,7 @@ pub struct AssetsMetadata {

1616const FILENAME: &str = "metadata.yaml";

1717

1818impl AssetsMetadata {

19+ #[cfg(feature = "build-assets")]

1920 pub(crate) fn new(current_version: &str) -> AssetsMetadata {

2021 AssetsMetadata {

2122 bat_version: Some(current_version.to_owned()),

@@ -23,6 +24,7 @@ impl AssetsMetadata {

2324 }

2425 }

2526

27+ #[cfg(feature = "build-assets")]

2628 pub(crate) fn save_to_folder(&self, path: &Path) -> Result<()> {

2729 let file = File::create(path.join(FILENAME))?;

2830 serde_yaml::to_writer(file, self)?;

@@ -50,16 +52,15 @@ impl AssetsMetadata {

5052 pub fn load_from_folder(path: &Path) -> Result<Option<Self>> {

5153 match Self::try_load_from_folder(path) {

5254 Ok(metadata) => Ok(Some(metadata)),

53− Err(e) => match e.kind() {

54− ErrorKind::SerdeYamlError(_) => Err(e),

55− _ => {

56− if path.join("syntaxes.bin").exists() || path.join("themes.bin").exists() {

57− Ok(Some(Self::default()))

58− } else {

59− Ok(None)

60− }

55+ Err(e) => {

56+ if let Error::SerdeYamlError(_) = e {

57+ Err(e)

58+ } else if path.join("syntaxes.bin").exists() || path.join("themes.bin").exists() {

59+ Ok(Some(Self::default()))

60+ } else {

61+ Ok(None)

6162 }

62− },

63+ }

6364 }

6465 }

6566

src/assets/build_assets.rsnew file+176

@@ -0,0 +1,176 @@

1+use std::convert::TryInto;

2+use std::path::Path;

4+use syntect::highlighting::ThemeSet;

5+use syntect::parsing::{SyntaxSet, SyntaxSetBuilder};

7+use crate::assets::*;

8+use acknowledgements::build_acknowledgements;

10+mod acknowledgements;

11+

12+pub fn build(

13+ source_dir: &Path,

14+ include_integrated_assets: bool,

15+ include_acknowledgements: bool,

16+ target_dir: &Path,

17+ current_version: &str,

18+) -> Result<()> {

19+ let theme_set = build_theme_set(source_dir, include_integrated_assets)?;

20+

21+ let syntax_set_builder = build_syntax_set_builder(source_dir, include_integrated_assets)?;

22+

23+ let syntax_set = syntax_set_builder.build();

24+

25+ let acknowledgements = build_acknowledgements(source_dir, include_acknowledgements)?;

26+

27+ print_unlinked_contexts(&syntax_set);

28+

29+ write_assets(

30+ &theme_set,

31+ &syntax_set,

32+ &acknowledgements,

33+ target_dir,

34+ current_version,

35+ )

36+}

37+

38+fn build_theme_set(source_dir: &Path, include_integrated_assets: bool) -> Result<LazyThemeSet> {

39+ let mut theme_set = if include_integrated_assets {

40+ crate::assets::get_integrated_themeset().try_into()?

41+ } else {

42+ ThemeSet::new()

43+ };

44+

45+ let theme_dir = source_dir.join("themes");

46+ if theme_dir.exists() {

47+ let res = theme_set.add_from_folder(&theme_dir);

48+ if let Err(err) = res {

49+ println!(

50+ "Failed to load one or more themes from '{}' (reason: '{}')",

51+ theme_dir.to_string_lossy(),

52+ err,

53+ );

54+ }

55+ } else {

56+ println!(

57+ "No themes were found in '{}', using the default set",

58+ theme_dir.to_string_lossy()

59+ );

60+ }

61+

62+ theme_set.try_into()

63+}

64+

65+fn build_syntax_set_builder(

66+ source_dir: &Path,

67+ include_integrated_assets: bool,

68+) -> Result<SyntaxSetBuilder> {

69+ let mut syntax_set_builder = if !include_integrated_assets {

70+ let mut builder = syntect::parsing::SyntaxSetBuilder::new();

71+ builder.add_plain_text_syntax();

72+ builder

73+ } else {

74+ from_binary::<SyntaxSet>(get_serialized_integrated_syntaxset(), COMPRESS_SYNTAXES)

75+ .into_builder()

76+ };

77+

78+ let syntax_dir = source_dir.join("syntaxes");

79+ if syntax_dir.exists() {

80+ syntax_set_builder.add_from_folder(syntax_dir, true)?;

81+ } else {

82+ println!(

83+ "No syntaxes were found in '{}', using the default set.",

84+ syntax_dir.to_string_lossy()

85+ );

86+ }

87+

88+ Ok(syntax_set_builder)

89+}

90+

91+fn print_unlinked_contexts(syntax_set: &SyntaxSet) {

92+ let missing_contexts = syntax_set.find_unlinked_contexts();

93+ if !missing_contexts.is_empty() {

94+ println!("Some referenced contexts could not be found!");

95+ for context in missing_contexts {

96+ println!("- {}", context);

97+ }

98+ }

99+}

100+

101+fn write_assets(

102+ theme_set: &LazyThemeSet,

103+ syntax_set: &SyntaxSet,

104+ acknowledgements: &Option<String>,

105+ target_dir: &Path,

106+ current_version: &str,

107+) -> Result<()> {

108+ let _ = std::fs::create_dir_all(target_dir);

109+ asset_to_cache(

110+ theme_set,

111+ &target_dir.join("themes.bin"),

112+ "theme set",

113+ COMPRESS_THEMES,

114+ )?;

115+ asset_to_cache(

116+ syntax_set,

117+ &target_dir.join("syntaxes.bin"),

118+ "syntax set",

119+ COMPRESS_SYNTAXES,

120+ )?;

121+

122+ if let Some(acknowledgements) = acknowledgements {

123+ asset_to_cache(

124+ acknowledgements,

125+ &target_dir.join("acknowledgements.bin"),

126+ "acknowledgements",

127+ COMPRESS_ACKNOWLEDGEMENTS,

128+ )?;

129+ }

130+

131+ print!(

132+ "Writing metadata to folder {} ... ",

133+ target_dir.to_string_lossy()

134+ );

135+ crate::assets_metadata::AssetsMetadata::new(current_version).save_to_folder(target_dir)?;

136+ println!("okay");

137+

138+ Ok(())

139+}

140+

141+pub(crate) fn asset_to_contents<T: serde::Serialize>(

142+ asset: &T,

143+ description: &str,

144+ compressed: bool,

145+) -> Result<Vec<u8>> {

146+ let mut contents = vec![];

147+ if compressed {

148+ bincode::serialize_into(

149+ flate2::write::ZlibEncoder::new(&mut contents, flate2::Compression::best()),

150+ asset,

151+ )

152+ } else {

153+ bincode::serialize_into(&mut contents, asset)

154+ }

155+ .map_err(|_| format!("Could not serialize {}", description))?;

156+ Ok(contents)

157+}

158+

159+fn asset_to_cache<T: serde::Serialize>(

160+ asset: &T,

161+ path: &Path,

162+ description: &str,

163+ compressed: bool,

164+) -> Result<()> {

165+ print!("Writing {} to {} ... ", description, path.to_string_lossy());

166+ let contents = asset_to_contents(asset, description, compressed)?;

167+ std::fs::write(path, &contents[..]).map_err(|_| {

168+ format!(

169+ "Could not save {} to {}",

170+ description,

171+ path.to_string_lossy()

172+ )

173+ })?;

174+ println!("okay");

175+ Ok(())

176+}

src/assets/build_assets/acknowledgements.rsnew file+222

@@ -0,0 +1,222 @@

1+use std::fs::read_to_string;

2+use std::path::{Path, PathBuf};

4+use walkdir::DirEntry;

6+use crate::error::*;

8+struct PathAndStem {

9+ path: PathBuf,

10+ stem: String,

11+ relative_path: String,

12+}

13+

14+/// Looks for LICENSE and NOTICE files in `source_dir`, does some rudimentary

15+/// analysis, and compiles them together in a single string that is meant to be

16+/// used in the output to `--acknowledgements`

17+pub fn build_acknowledgements(

18+ source_dir: &Path,

19+ include_acknowledgements: bool,

20+) -> Result<Option<String>> {

21+ if !include_acknowledgements {

22+ return Ok(None);

23+ }

24+

25+ let mut acknowledgements = format!("{}\n\n", include_str!("../../../NOTICE"));

26+

27+ // Sort entries so the order is stable over time

28+ let entries = walkdir::WalkDir::new(source_dir).sort_by(|a, b| a.path().cmp(b.path()));

29+ for path_and_stem in entries

30+ .into_iter()

31+ .flatten()

32+ .flat_map(|entry| to_path_and_stem(source_dir, entry))

33+ {

34+ if let Some(license_text) = handle_file(&path_and_stem)? {

35+ append_to_acknowledgements(

36+ &mut acknowledgements,

37+ &path_and_stem.relative_path,

38+ &license_text,

39+ )

40+ }

41+ }

42+

43+ Ok(Some(acknowledgements))

44+}

45+

46+fn to_path_and_stem(source_dir: &Path, entry: DirEntry) -> Option<PathAndStem> {

47+ let path = entry.path();

48+

49+ Some(PathAndStem {

50+ path: path.to_owned(),

51+ stem: path.file_stem().map(|s| s.to_string_lossy().to_string())?,

52+ relative_path: path

53+ .strip_prefix(source_dir)

54+ .map(|p| p.to_string_lossy().to_string())

55+ .ok()?,

56+ })

57+}

58+

59+fn handle_file(path_and_stem: &PathAndStem) -> Result<Option<String>> {

60+ if path_and_stem.stem == "NOTICE" {

61+ handle_notice(&path_and_stem.path)

62+ } else if path_and_stem.stem.to_ascii_uppercase() == "LICENSE" {

63+ handle_license(&path_and_stem.path)

64+ } else {

65+ Ok(None)

66+ }

67+}

68+

69+fn handle_notice(path: &Path) -> Result<Option<String>> {

70+ // Assume NOTICE as defined by Apache License 2.0. These must be part of acknowledgements.

71+ Ok(Some(read_to_string(path)?))

72+}

73+

74+fn handle_license(path: &Path) -> Result<Option<String>> {

75+ let license_text = read_to_string(path)?;

76+

77+ if include_license_in_acknowledgments(&license_text) {

78+ Ok(Some(license_text))

79+ } else if license_not_needed_in_acknowledgements(&license_text) {

80+ Ok(None)

81+ } else {

82+ Err(format!("ERROR: License is of unknown type: {:?}", path).into())

83+ }

84+}

85+

86+fn include_license_in_acknowledgments(license_text: &str) -> bool {

87+ let markers = vec![

88+ // MIT

89+ "The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.",

90+

91+ // BSD

92+ "Redistributions in binary form must reproduce the above copyright notice,",

93+

94+ // Apache 2.0

95+ "Apache License Version 2.0, January 2004 http://www.apache.org/licenses/",

96+ "Licensed under the Apache License, Version 2.0 (the \"License\");",

97+ ];

98+

99+ license_contains_marker(license_text, &markers)

100+}

101+

102+fn license_not_needed_in_acknowledgements(license_text: &str) -> bool {

103+ let markers = vec![

104+ // Public domain

105+ "This is free and unencumbered software released into the public domain.",

106+

107+ // Public domain with stronger wording than above

108+ "DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE",

109+

110+ // Special license of assets/syntaxes/01_Packages/LICENSE

111+ "Permission to copy, use, modify, sell and distribute this software is granted. This software is provided \"as is\" without express or implied warranty, and with no claim as to its suitability for any purpose."

112+ ];

113+

114+ license_contains_marker(license_text, &markers)

115+}

116+

117+fn license_contains_marker(license_text: &str, markers: &[&str]) -> bool {

118+ let normalized_license_text = normalize_license_text(license_text);

119+ markers.iter().any(|m| normalized_license_text.contains(m))

120+}

121+

122+fn append_to_acknowledgements(

123+ acknowledgements: &mut String,

124+ relative_path: &str,

125+ license_text: &str,

126+) {

127+ acknowledgements.push_str(&format!("## {}\n\n{}", relative_path, license_text));

128+

129+ // Make sure the last char is a newline to not mess up formatting later

130+ if acknowledgements

131+ .chars()

132+ .last()

133+ .expect("acknowledgements is not the empty string")

134+ != '\n'

135+ {

136+ acknowledgements.push('\n');

137+ }

138+

139+ // Add two more newlines to make it easy to distinguish where this text ends

140+ // and the next starts

141+ acknowledgements.push_str("\n\n");

142+}

143+

144+/// Replaces newlines with a space character, and replaces multiple spaces with one space.

145+/// This makes the text easier to analyze.

146+fn normalize_license_text(license_text: &str) -> String {

147+ use regex::Regex;

148+

149+ let whitespace_and_newlines = Regex::new(r"\s").unwrap();

150+ let as_single_line = whitespace_and_newlines.replace_all(license_text, " ");

151+

152+ let many_spaces = Regex::new(" +").unwrap();

153+ many_spaces.replace_all(&as_single_line, " ").to_string()

154+}

155+

156+#[cfg(test)]

157+mod tests {

158+ #[cfg(test)]

159+ use super::*;

160+

161+ #[test]

162+ fn test_normalize_license_text() {

163+ let license_text = "This is a license text with these terms:

164+ * Complicated multi-line

165+ term with indentation";

166+

167+ assert_eq!(

168+ "This is a license text with these terms: * Complicated multi-line term with indentation".to_owned(),

169+ normalize_license_text(license_text),

170+ );

171+ }

172+

173+ #[test]

174+ fn test_normalize_license_text_with_windows_line_endings() {

175+ let license_text = "This license text includes windows line endings\r

176+and we need to handle that.";

177+

178+ assert_eq!(

179+ "This license text includes windows line endings and we need to handle that."

180+ .to_owned(),

181+ normalize_license_text(license_text),

182+ );

183+ }

184+

185+ #[test]

186+ fn test_append_to_acknowledgements_adds_newline_if_missing() {

187+ let mut acknowledgements = "preamble\n\n\n".to_owned();

188+

189+ append_to_acknowledgements(&mut acknowledgements, "some/path", "line without newline");

190+ assert_eq!(

191+ "preamble

192+

193+

194+## some/path

195+

196+line without newline

197+

198+

199+",

200+ acknowledgements

201+ );

202+

203+ append_to_acknowledgements(&mut acknowledgements, "another/path", "line with newline\n");

204+ assert_eq!(

205+ "preamble

206+

207+

208+## some/path

209+

210+line without newline

211+

212+

213+## another/path

214+

215+line with newline

216+

217+

218+",

219+ acknowledgements

220+ );

221+ }

222+}

src/assets/lazy_theme_set.rsnew file+104

@@ -0,0 +1,104 @@

1+use super::*;

3+use std::collections::BTreeMap;

4+use std::convert::TryFrom;

6+use serde::Deserialize;

7+use serde::Serialize;

9+use once_cell::unsync::OnceCell;

10+

11+use syntect::highlighting::{Theme, ThemeSet};

12+

13+/// Same structure as a [`syntect::highlighting::ThemeSet`] but with themes

14+/// stored in raw serialized form, and deserialized on demand.

15+#[derive(Debug, Default, Serialize, Deserialize)]

16+pub struct LazyThemeSet {

17+ /// This is a [`BTreeMap`] because that's what [`syntect::highlighting::ThemeSet`] uses

18+ themes: BTreeMap<String, LazyTheme>,

19+}

20+

21+/// Stores raw serialized data for a theme with methods to lazily deserialize

22+/// (load) the theme.

23+#[derive(Debug, Serialize, Deserialize)]

24+struct LazyTheme {

25+ serialized: Vec<u8>,

26+

27+ #[serde(skip, default = "OnceCell::new")]

28+ deserialized: OnceCell<syntect::highlighting::Theme>,

29+}

30+

31+impl LazyThemeSet {

32+ /// Lazily load the given theme

33+ pub fn get(&self, name: &str) -> Option<&Theme> {

34+ self.themes.get(name).and_then(|lazy_theme| {

35+ lazy_theme

36+ .deserialized

37+ .get_or_try_init(|| lazy_theme.deserialize())

38+ .ok()

39+ })

40+ }

41+

42+ /// Returns the name of all themes.

43+ pub fn themes(&self) -> impl Iterator<Item = &str> {

44+ self.themes.keys().map(|name| name.as_ref())

45+ }

46+}

47+

48+impl LazyTheme {

49+ fn deserialize(&self) -> Result<Theme> {

50+ asset_from_contents(

51+ &self.serialized[..],

52+ "lazy-loaded theme",

53+ COMPRESS_LAZY_THEMES,

54+ )

55+ }

56+}

57+

58+impl TryFrom<LazyThemeSet> for ThemeSet {

59+ type Error = Error;

60+

61+ /// Since the user might want to add custom themes to bat, we need a way to

62+ /// convert from a `LazyThemeSet` to a regular [`ThemeSet`] so that more

63+ /// themes can be added. This function does that pretty straight-forward

64+ /// conversion.

65+ fn try_from(lazy_theme_set: LazyThemeSet) -> Result<Self> {

66+ let mut theme_set = ThemeSet::default();

67+

68+ for (name, lazy_theme) in lazy_theme_set.themes {

69+ theme_set.themes.insert(name, lazy_theme.deserialize()?);

70+ }

71+

72+ Ok(theme_set)

73+ }

74+}

75+

76+#[cfg(feature = "build-assets")]

77+impl TryFrom<ThemeSet> for LazyThemeSet {

78+ type Error = Error;

79+

80+ /// To collect themes, a [`ThemeSet`] is needed. Once all desired themes

81+ /// have been added, we need a way to convert that into [`LazyThemeSet`] so

82+ /// that themes can be lazy-loaded later. This function does that

83+ /// conversion.

84+ fn try_from(theme_set: ThemeSet) -> Result<Self> {

85+ let mut lazy_theme_set = LazyThemeSet::default();

86+

87+ for (name, theme) in theme_set.themes {

88+ // All we have to do is to serialize the theme

89+ let lazy_theme = LazyTheme {

90+ serialized: crate::assets::build_assets::asset_to_contents(

91+ &theme,

92+ &format!("theme {}", name),

93+ COMPRESS_LAZY_THEMES,

94+ )?,

95+ deserialized: OnceCell::new(),

96+ };

97+

98+ // Ok done, now we can add it

99+ lazy_theme_set.themes.insert(name, lazy_theme);

100+ }

101+

102+ Ok(lazy_theme_set)

103+ }

104+}

src/assets/serialized_syntax_set.rsnew file+27

@@ -0,0 +1,27 @@

1+use std::path::PathBuf;

3+use syntect::parsing::SyntaxSet;

5+use super::*;

7+/// A SyntaxSet in serialized form, i.e. bincoded and flate2 compressed.

8+/// We keep it in this format since we want to load it lazily.

9+#[derive(Debug)]

10+pub enum SerializedSyntaxSet {

11+ /// The data comes from a user-generated cache file.

12+ FromFile(PathBuf),

13+

14+ /// The data to use is embedded into the bat binary.

15+ FromBinary(&'static [u8]),

16+}

17+

18+impl SerializedSyntaxSet {

19+ pub fn deserialize(&self) -> Result<SyntaxSet> {

20+ match self {

21+ SerializedSyntaxSet::FromBinary(data) => Ok(from_binary(data, COMPRESS_SYNTAXES)),

22+ SerializedSyntaxSet::FromFile(ref path) => {

23+ asset_from_cache(path, "syntax set", COMPRESS_SYNTAXES)

24+ }

25+ }

26+ }

27+}

src/bin/bat/app.rs+29−23

@@ -1,6 +1,6 @@

11use std::collections::HashSet;

22use std::env;

3−use std::ffi::OsStr;

3+use std::path::Path;

44use std::str::FromStr;

66use atty::{self, Stream};

@@ -16,6 +16,7 @@ use console::Term;

1616use crate::input::{new_file_input, new_stdin_input};

1717use bat::{

1818 assets::HighlightingAssets,

19+ bat_warning,

1920 config::{Config, VisibleLines},

2021 error::*,

2122 input::Input,

@@ -61,7 +62,7 @@ impl App {

6162 // Read arguments from bats config file

6263 let mut args = get_args_from_env_var()

6364 .unwrap_or_else(get_args_from_config_file)

64− .chain_err(|| "Could not parse configuration file")?;

65+ .map_err(|_| "Could not parse configuration file")?;

6566

6667 // Put the zero-th CLI argument (program name) first

6768 args.insert(0, cli_args.next().unwrap());

@@ -82,10 +83,9 @@ impl App {

8283 Some("always") => PagingMode::Always,

8384 Some("never") => PagingMode::Never,

8485 Some("auto") | None => {

85− if self.matches.occurrences_of("plain") > 1 {

86− // If we have -pp as an option when in auto mode, the pager should be disabled.

87− PagingMode::Never

88− } else if self.matches.is_present("no-paging") {

86+ // If we have -pp as an option when in auto mode, the pager should be disabled.

87+ let extra_plain = self.matches.occurrences_of("plain") > 1;

88+ if extra_plain || self.matches.is_present("no-paging") {

8989 PagingMode::Never

9090 } else if inputs.iter().any(Input::is_stdin) {

9191 // If we are reading from stdin, only enable paging if we write to an

@@ -107,6 +107,12 @@ impl App {

107107

108108 let mut syntax_mapping = SyntaxMapping::builtin();

109109

110+ if let Some(values) = self.matches.values_of("ignored-suffix") {

111+ for suffix in values {

112+ syntax_mapping.insert_ignored_suffix(suffix);

113+ }

114+ }

115+

110116 if let Some(values) = self.matches.values_of("map-syntax") {

111117 for from_to in values {

112118 let parts: Vec<_> = from_to.split(':').collect();

@@ -150,20 +156,20 @@ impl App {

150156 wrapping_mode: if self.interactive_output || maybe_term_width.is_some() {

151157 match self.matches.value_of("wrap") {

152158 Some("character") => WrappingMode::Character,

153− Some("never") => WrappingMode::NoWrapping,

159+ Some("never") => WrappingMode::NoWrapping(true),

154160 Some("auto") | None => {

155161 if style_components.plain() {

156− WrappingMode::NoWrapping

162+ WrappingMode::NoWrapping(false)

157163 } else {

158164 WrappingMode::Character

159165 }

160166 }

161− _ => unreachable!("other values for --paging are not allowed"),

167+ _ => unreachable!("other values for --wrap are not allowed"),

162168 }

163169 } else {

164170 // We don't have the tty width when piping to another program.

165171 // There's no point in wrapping when this is the case.

166− WrappingMode::NoWrapping

172+ WrappingMode::NoWrapping(false)

167173 },

168174 colored_output: self.matches.is_present("force-colorization")

169175 || match self.matches.value_of("color") {

@@ -234,6 +240,7 @@ impl App {

234240 .map(LineRanges::from)

235241 .map(HighlightedLineRanges)

236242 .unwrap_or_default(),

243+ use_custom_assets: !self.matches.is_present("no-custom-assets"),

237244 })

238245 }

239246

@@ -248,16 +255,19 @@ impl App {

248255 }

249256 _ => {}

250257 }

251− let filenames: Option<Vec<&str>> = self

258+ let filenames: Option<Vec<&Path>> = self

252259 .matches

253− .values_of("file-name")

254− .map(|values| values.collect());

260+ .values_of_os("file-name")

261+ .map(|values| values.map(Path::new).collect());

255262

256− let mut filenames_or_none: Box<dyn Iterator<Item = _>> = match filenames {

257− Some(ref filenames) => Box::new(filenames.iter().map(|name| Some(OsStr::new(*name)))),

263+ let mut filenames_or_none: Box<dyn Iterator<Item = Option<&Path>>> = match filenames {

264+ Some(filenames) => Box::new(filenames.into_iter().map(Some)),

258265 None => Box::new(std::iter::repeat(None)),

259266 };

260− let files: Option<Vec<&OsStr>> = self.matches.values_of_os("FILE").map(|vs| vs.collect());

267+ let files: Option<Vec<&Path>> = self

268+ .matches

269+ .values_of_os("FILE")

270+ .map(|vs| vs.map(Path::new).collect());

261271

262272 if files.is_none() {

263273 return Ok(vec![new_stdin_input(

@@ -297,7 +307,7 @@ impl App {

297307 .map(|style_str| {

298308 style_str

299309 .split(',')

300− .map(|x| StyleComponent::from_str(&x))

310+ .map(StyleComponent::from_str)

301311 .collect::<Result<Vec<StyleComponent>>>()

302312 })

303313 .transpose()?;

@@ -312,7 +322,7 @@ impl App {

312322 .collect::<Vec<_>>()

313323 })

314324 .or(env_style_components)

315− .unwrap_or_else(|| vec![StyleComponent::Full])

325+ .unwrap_or_else(|| vec![StyleComponent::Default])

316326 .into_iter()

317327 .map(|style| style.components(self.interactive_output))

318328 .fold(HashSet::new(), |mut acc, components| {

@@ -323,11 +333,7 @@ impl App {

323333

324334 // If `grid` is set, remove `rule` as it is a subset of `grid`, and print a warning.

325335 if styled_components.grid() && styled_components.0.remove(&StyleComponent::Rule) {

326− use ansi_term::Colour::Yellow;

327− eprintln!(

328− "{}: Style 'rule' is a subset of style 'grid', 'rule' will not be visible.",

329− Yellow.paint("[bat warning]"),

330− );

336+ bat_warning!("Style 'rule' is a subset of style 'grid', 'rule' will not be visible.");

331337 }

332338

333339 Ok(styled_components)

src/bin/bat/assets.rs+26−19

@@ -1,5 +1,6 @@

11use std::borrow::Cow;

22use std::fs;

3+use std::io;

45use clap::crate_version;

@@ -18,26 +19,14 @@ pub fn cache_dir() -> Cow<'static, str> {

1819}

1920

2021pub fn clear_assets() {

21− let theme_set_path = PROJECT_DIRS.cache_dir().join("themes.bin");

22− let syntax_set_path = PROJECT_DIRS.cache_dir().join("syntaxes.bin");

23− let metadata_file = PROJECT_DIRS.cache_dir().join("metadata.yaml");

24−

25− print!("Clearing theme set cache ... ");

26− fs::remove_file(theme_set_path).ok();

27− println!("okay");

28−

29− print!("Clearing syntax set cache ... ");

30− fs::remove_file(syntax_set_path).ok();

31− println!("okay");

32−

33− print!("Clearing metadata file ... ");

34− fs::remove_file(metadata_file).ok();

35− println!("okay");

22+ clear_asset("themes.bin", "theme set cache");

23+ clear_asset("syntaxes.bin", "syntax set cache");

24+ clear_asset("metadata.yaml", "metadata file");

3625}

3726

38−pub fn assets_from_cache_or_binary() -> Result<HighlightingAssets> {

27+pub fn assets_from_cache_or_binary(use_custom_assets: bool) -> Result<HighlightingAssets> {

3928 let cache_dir = PROJECT_DIRS.cache_dir();

40− if let Some(metadata) = AssetsMetadata::load_from_folder(&cache_dir)? {

29+ if let Some(metadata) = AssetsMetadata::load_from_folder(cache_dir)? {

4130 if !metadata.is_compatible_with(crate_version!()) {

4231 return Err(format!(

4332 "The binary caches for the user-customized syntaxes and themes \

@@ -53,6 +42,24 @@ pub fn assets_from_cache_or_binary() -> Result<HighlightingAssets> {

5342 }

5443 }

5544

56− Ok(HighlightingAssets::from_cache(&cache_dir)

57− .unwrap_or_else(|_| HighlightingAssets::from_binary()))

45+ let custom_assets = if use_custom_assets {

46+ HighlightingAssets::from_cache(cache_dir).ok()

47+ } else {

48+ None

49+ };

50+ Ok(custom_assets.unwrap_or_else(HighlightingAssets::from_binary))

51+}

52+

53+fn clear_asset(filename: &str, description: &str) {

54+ print!("Clearing {} ... ", description);

55+ let path = PROJECT_DIRS.cache_dir().join(filename);

56+ match fs::remove_file(&path) {

57+ Err(err) if err.kind() == io::ErrorKind::NotFound => {

58+ println!("skipped (not present)");

59+ }

60+ Err(err) => {

61+ println!("could not remove the cache file {:?}: {}", &path, err);

62+ }

63+ Ok(_) => println!("okay"),

64+ }

5865}

src/bin/bat/clap_app.rs+78−11

@@ -1,7 +1,21 @@

11use clap::{crate_name, crate_version, App as ClapApp, AppSettings, Arg, ArgGroup, SubCommand};

2+use once_cell::sync::Lazy;

23use std::env;

34use std::path::Path;

6+static VERSION: Lazy<String> = Lazy::new(|| {

7+ #[cfg(feature = "bugreport")]

8+ let git_version = bugreport::git_version!(fallback = "");

9+ #[cfg(not(feature = "bugreport"))]

10+ let git_version = "";

11+

12+ if git_version.is_empty() {

13+ crate_version!().to_string()

14+ } else {

15+ format!("{} ({})", crate_version!(), git_version)

16+ }

17+});

18+

519pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {

620 let clap_color_setting = if interactive_output && env::var_os("NO_COLOR").is_none() {

721 AppSettings::ColoredHelp

@@ -10,7 +24,7 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {

1024 };

1125

1226 let mut app = ClapApp::new(crate_name!())

13− .version(crate_version!())

27+ .version(VERSION.as_str())

1428 .global_setting(clap_color_setting)

1529 .global_setting(AppSettings::DeriveDisplayOrder)

1630 .global_setting(AppSettings::UnifiedHelpMessage)

@@ -95,7 +109,8 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {

95109 '--highlight-line 40' highlights line 40\n \

96110 '--highlight-line 30:40' highlights lines 30 to 40\n \

97111 '--highlight-line :40' highlights lines 1 to 40\n \

98− '--highlight-line 40:' highlights lines 40 to the end of the file",

112+ '--highlight-line 40:' highlights lines 40 to the end of the file\n \

113+ '--highlight-line 30:+10' highlights lines 30 to 40",

99114 ),

100115 )

101116 .arg(

@@ -294,6 +309,7 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {

294309 .arg(

295310 Arg::with_name("no-paging")

296311 .short("P")

312+ .long("no-paging")

297313 .alias("no-pager")

298314 .overrides_with("no-paging")

299315 .hidden(true)

@@ -328,10 +344,23 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {

328344 "Map a glob pattern to an existing syntax name. The glob pattern is matched \

329345 on the full path and the filename. For example, to highlight *.build files \

330346 with the Python syntax, use -m '*.build:Python'. To highlight files named \

331− '.myignore' with the Git Ignore syntax, use -m '.myignore:Git Ignore'.",

347+ '.myignore' with the Git Ignore syntax, use -m '.myignore:Git Ignore'. Note \

348+ that the right-hand side is the *name* of the syntax, not a file extension.",

332349 )

333350 .takes_value(true),

334351 )

352+ .arg(

353+ Arg::with_name("ignored-suffix")

354+ .number_of_values(1)

355+ .multiple(true)

356+ .takes_value(true)

357+ .long("ignored-suffix")

358+ .hidden_short_help(true)

359+ .help(

360+ "Ignore extension. For example:\n \

361+ 'bat --ignored-suffix \".dev\" my_file.json.dev' will use JSON syntax, and ignore '.dev'"

362+ )

363+ )

335364 .arg(

336365 Arg::with_name("theme")

337366 .long("theme")

@@ -367,11 +396,20 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {

367396 .validator(|val| {

368397 let mut invalid_vals = val.split(',').filter(|style| {

369398 !&[

370− "auto", "full", "plain", "header", "grid", "rule", "numbers", "snip",

399+ "auto",

400+ "full",

401+ "default",

402+ "plain",

403+ "header",

404+ "header-filename",

405+ "header-filesize",

406+ "grid",

407+ "rule",

408+ "numbers",

409+ "snip",

371410 #[cfg(feature = "git")]

372− "changes",

373− ]

374− .contains(style)

411+ "changes",

412+ ].contains(style)

375413 });

376414

377415 if let Some(invalid) = invalid_vals.next() {

@@ -382,7 +420,7 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {

382420 })

383421 .help(

384422 "Comma-separated list of style elements to display \

385− (*auto*, full, plain, changes, header, grid, rule, numbers, snip).",

423+ (*default*, auto, full, plain, changes, header, header-filename, header-filesize, grid, rule, numbers, snip).",

386424 )

387425 .long_help(

388426 "Configure which elements (line numbers, file headers, grid \

@@ -393,11 +431,14 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {

393431 '--style=\"..\"' option to the configuration file or export the \

394432 BAT_STYLE environment variable (e.g.: export BAT_STYLE=\"..\").\n\n\

395433 Possible values:\n\n \

434+ * default: enables recommended style components (default).\n \

396435 * full: enables all available components.\n \

397− * auto: same as 'full', unless the output is piped (default).\n \

436+ * auto: same as 'default', unless the output is piped.\n \

398437 * plain: disables all available components.\n \

399438 * changes: show Git modification markers.\n \

400− * header: show filenames before the content.\n \

439+ * header: alias for 'header-filename'.\n \

440+ * header-filename: show filenames before the content.\n \

441+ * header-filesize: show file sizes before the content.\n \

401442 * grid: vertical/horizontal lines to separate side bar\n \

402443 and the header from the content.\n \

403444 * rule: horizontal lines to delimit files.\n \

@@ -421,7 +462,8 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {

421462 '--line-range 30:40' prints lines 30 to 40\n \

422463 '--line-range :40' prints lines 1 to 40\n \

423464 '--line-range 40:' prints lines 40 to the end of the file\n \

424− '--line-range 40' only prints line 40",

465+ '--line-range 40' only prints line 40\n \

466+ '--line-range 30:+10' prints lines 30 to 40",

425467 ),

426468 )

427469 .arg(

@@ -449,6 +491,12 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {

449491 .hidden(true)

450492 .help("Do not use the configuration file"),

451493 )

494+ .arg(

495+ Arg::with_name("no-custom-assets")

496+ .long("no-custom-assets")

497+ .hidden(true)

498+ .help("Do not load custom assets"),

499+ )

452500 .arg(

453501 Arg::with_name("config-file")

454502 .long("config-file")

@@ -477,6 +525,19 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {

477525 .hidden(true)

478526 .help("Show bat's cache directory."),

479527 )

528+ .arg(

529+ Arg::with_name("diagnostic")

530+ .long("diagnostic")

531+ .alias("diagnostics")

532+ .hidden_short_help(true)

533+ .help("Show diagnostic information for bug reports.")

534+ )

535+ .arg(

536+ Arg::with_name("acknowledgements")

537+ .long("acknowledgements")

538+ .hidden_short_help(true)

539+ .help("Show acknowledgements."),

540+ )

480541 .help_message("Print this help message.")

481542 .version_message("Show version information.");

482543

@@ -535,6 +596,12 @@ pub fn build_app(interactive_output: bool) -> ClapApp<'static, 'static> {

535596 "Create completely new syntax and theme sets \

536597 (instead of appending to the default sets).",

537598 ),

599+ )

600+ .arg(

601+ Arg::with_name("acknowledgements")

602+ .long("acknowledgements")

603+ .requires("build")

604+ .help("Build acknowledgements.bin."),

538605 ),

539606 )

540607 }

src/bin/bat/config.rs+12−6

@@ -10,13 +10,12 @@ pub fn config_file() -> PathBuf {

1010 env::var("BAT_CONFIG_PATH")

1111 .ok()

1212 .map(PathBuf::from)

13− .filter(|config_path| config_path.is_file())

1413 .unwrap_or_else(|| PROJECT_DIRS.config_dir().join("config"))

1514}

1615

1716pub fn generate_config_file() -> bat::error::Result<()> {

1817 let config_file = config_file();

19− if config_file.exists() {

18+ if config_file.is_file() {

2019 println!(

2120 "A config file already exists at: {}",

2221 config_file.to_string_lossy()

@@ -65,13 +64,20 @@ pub fn generate_config_file() -> bat::error::Result<()> {

6564#--pager="less --RAW-CONTROL-CHARS --quit-if-one-screen --mouse"

6665

6766# Syntax mappings: map a certain filename pattern to a language.

68−# Example 1: use the C++ syntax for .ino files

67+# Example 1: use the C++ syntax for Arduino .ino files

6968# Example 2: Use ".gitignore"-style highlighting for ".ignore" files

7069#--map-syntax "*.ino:C++"

7170#--map-syntax ".ignore:Git Ignore"

7271"#;

7372

74− fs::write(&config_file, default_config)?;

73+ fs::write(&config_file, default_config).map_err(|e| {

74+ format!(

75+ "Failed to create config file at '{}': {}",

76+ config_file.to_string_lossy(),

77+ e

78+ )

79+ })?;

80+

7581 println!(

7682 "Success! Config file written to {}",

7783 config_file.to_string_lossy()

@@ -85,7 +91,7 @@ pub fn get_args_from_config_file() -> Result<Vec<OsString>, shell_words::ParseEr

8591 .ok()

8692 .map(|content| get_args_from_str(&content))

8793 .transpose()?

88− .unwrap_or_else(Vec::new))

94+ .unwrap_or_default())

8995}

9096

9197pub fn get_args_from_env_var() -> Option<Result<Vec<OsString>, shell_words::ParseError>> {

@@ -98,7 +104,7 @@ fn get_args_from_str(content: &str) -> Result<Vec<OsString>, shell_words::ParseE

98104 .map(|line| line.trim())

99105 .filter(|line| !line.is_empty())

100106 .filter(|line| !line.starts_with('#'))

101− .map(|line| shell_words::split(line))

107+ .map(shell_words::split)

102108 .collect::<Result<Vec<_>, _>>()?;

103109

104110 Ok(args_per_line

src/bin/bat/directories.rs+23−17

@@ -1,11 +1,12 @@

11use std::env;

22use std::path::{Path, PathBuf};

4−use lazy_static::lazy_static;

4+use once_cell::sync::Lazy;

66/// Wrapper for 'dirs' that treats MacOS more like Linux, by following the XDG specification.

7−/// This means that the `XDG_CACHE_HOME` and `XDG_CONFIG_HOME` environment variables are

8−/// checked first. The fallback directories are `~/.cache/bat` and `~/.config/bat`, respectively.

7+/// The `XDG_CACHE_HOME` environment variable is checked first. `BAT_CONFIG_DIR`

8+/// is then checked before the `XDG_CONFIG_HOME` environment variable.

9+/// The fallback directories are `~/.cache/bat` and `~/.config/bat`, respectively.

910pub struct BatProjectDirs {

1011 cache_dir: PathBuf,

1112 config_dir: PathBuf,

@@ -15,16 +16,23 @@ impl BatProjectDirs {

1516 fn new() -> Option<BatProjectDirs> {

1617 let cache_dir = BatProjectDirs::get_cache_dir()?;

1718

18− #[cfg(target_os = "macos")]

19− let config_dir_op = env::var_os("XDG_CONFIG_HOME")

20− .map(PathBuf::from)

21− .filter(|p| p.is_absolute())

22− .or_else(|| dirs::home_dir().map(|d| d.join(".config")));

19+ // Checks whether or not $BAT_CONFIG_DIR exists. If it doesn't, set our config dir

20+ // to our system's default configuration home.

21+ let config_dir =

22+ if let Some(config_dir_op) = env::var_os("BAT_CONFIG_DIR").map(PathBuf::from) {

23+ config_dir_op

24+ } else {

25+ #[cfg(target_os = "macos")]

26+ let config_dir_op = env::var_os("XDG_CONFIG_HOME")

27+ .map(PathBuf::from)

28+ .filter(|p| p.is_absolute())

29+ .or_else(|| dirs_next::home_dir().map(|d| d.join(".config")));

2330

24− #[cfg(not(target_os = "macos"))]

25− let config_dir_op = dirs::config_dir();

31+ #[cfg(not(target_os = "macos"))]

32+ let config_dir_op = dirs_next::config_dir();

2633

27− let config_dir = config_dir_op.map(|d| d.join("bat"))?;

34+ config_dir_op.map(|d| d.join("bat"))?

35+ };

2836

2937 Some(BatProjectDirs {

3038 cache_dir,

@@ -43,10 +51,10 @@ impl BatProjectDirs {

4351 let cache_dir_op = env::var_os("XDG_CACHE_HOME")

4452 .map(PathBuf::from)

4553 .filter(|p| p.is_absolute())

46− .or_else(|| dirs::home_dir().map(|d| d.join(".cache")));

54+ .or_else(|| dirs_next::home_dir().map(|d| d.join(".cache")));

4755

4856 #[cfg(not(target_os = "macos"))]

49− let cache_dir_op = dirs::cache_dir();

57+ let cache_dir_op = dirs_next::cache_dir();

5058

5159 cache_dir_op.map(|d| d.join("bat"))

5260 }

@@ -60,7 +68,5 @@ impl BatProjectDirs {

6068 }

6169}

6270

63−lazy_static! {

64− pub static ref PROJECT_DIRS: BatProjectDirs =

65− BatProjectDirs::new().expect("Could not get home directory");

66−}

71+pub static PROJECT_DIRS: Lazy<BatProjectDirs> =

72+ Lazy::new(|| BatProjectDirs::new().expect("Could not get home directory"));

src/bin/bat/input.rs+5−5

@@ -1,15 +1,15 @@

11use bat::input::Input;

2−use std::ffi::OsStr;

2+use std::path::Path;

4−pub fn new_file_input<'a>(file: &'a OsStr, name: Option<&'a OsStr>) -> Input<'a> {

5− named(Input::ordinary_file(file), name.or_else(|| Some(file)))

4+pub fn new_file_input<'a>(file: &'a Path, name: Option<&'a Path>) -> Input<'a> {

5+ named(Input::ordinary_file(file), name.or(Some(file)))

66}

8−pub fn new_stdin_input(name: Option<&OsStr>) -> Input {

8+pub fn new_stdin_input(name: Option<&Path>) -> Input {

99 named(Input::stdin(), name)

1010}

1111

12−fn named<'a>(input: Input<'a>, name: Option<&OsStr>) -> Input<'a> {

12+fn named<'a>(input: Input<'a>, name: Option<&Path>) -> Input<'a> {

1313 if let Some(provided_name) = name {

1414 let mut input = input.with_name(Some(provided_name));

1515 input.description_mut().set_kind(Some("File".to_owned()));

src/bin/bat/main.rs+134−61

@@ -1,5 +1,4 @@

1−// `error_chain!` can recurse deeply

2−#![recursion_limit = "1024"]

1+#![deny(unsafe_code)]

43mod app;

54mod assets;

@@ -9,7 +8,6 @@ mod directories;

98mod input;

109

1110use std::collections::{HashMap, HashSet};

12−use std::ffi::OsStr;

1311use std::io;

1412use std::io::{BufReader, Write};

1513use std::path::Path;

@@ -24,37 +22,46 @@ use crate::{

2422};

2523

2624use assets::{assets_from_cache_or_binary, cache_dir, clear_assets, config_dir};

27−use clap::crate_version;

2825use directories::PROJECT_DIRS;

2926use globset::GlobMatcher;

3027

3128use bat::{

32− assets::HighlightingAssets,

3329 config::Config,

3430 controller::Controller,

3531 error::*,

3632 input::Input,

3733 style::{StyleComponent, StyleComponents},

38− MappingTarget,

34+ MappingTarget, PagingMode,

3935};

4036

4137const THEME_PREVIEW_DATA: &[u8] = include_bytes!("../../../assets/theme_preview.rs");

4238

39+#[cfg(feature = "build-assets")]

40+fn build_assets(matches: &clap::ArgMatches) -> Result<()> {

41+ let source_dir = matches

42+ .value_of("source")

43+ .map(Path::new)

44+ .unwrap_or_else(|| PROJECT_DIRS.config_dir());

45+ let target_dir = matches

46+ .value_of("target")

47+ .map(Path::new)

48+ .unwrap_or_else(|| PROJECT_DIRS.cache_dir());

49+

50+ bat::assets::build(

51+ source_dir,

52+ !matches.is_present("blank"),

53+ matches.is_present("acknowledgements"),

54+ target_dir,

55+ clap::crate_version!(),

56+ )

57+}

58+

4359fn run_cache_subcommand(matches: &clap::ArgMatches) -> Result<()> {

4460 if matches.is_present("build") {

45− let source_dir = matches

46− .value_of("source")

47− .map(Path::new)

48− .unwrap_or_else(|| PROJECT_DIRS.config_dir());

49− let target_dir = matches

50− .value_of("target")

51− .map(Path::new)

52− .unwrap_or_else(|| PROJECT_DIRS.cache_dir());

53−

54− let blank = matches.is_present("blank");

55−

56− let assets = HighlightingAssets::from_files(source_dir, !blank)?;

57− assets.save_to_cache(target_dir, crate_version!())?;

61+ #[cfg(feature = "build-assets")]

62+ build_assets(matches)?;

63+ #[cfg(not(feature = "build-assets"))]

64+ println!("bat has been built without the 'build-assets' feature. The 'cache --build' option is not available.");

5865 } else if matches.is_present("clear") {

5966 clear_assets();

6067 }

@@ -67,28 +74,27 @@ fn get_syntax_mapping_to_paths<'a>(

6774) -> HashMap<&'a str, Vec<String>> {

6875 let mut map = HashMap::new();

6976 for mapping in mappings {

70− match mapping {

71− (_, MappingTarget::MapToUnknown) => {}

72− (matcher, MappingTarget::MapTo(s)) => {

73− let globs = map.entry(*s).or_insert_with(Vec::new);

74− globs.push(matcher.glob().glob().into());

75− }

77+ if let (matcher, MappingTarget::MapTo(s)) = mapping {

78+ let globs = map.entry(*s).or_insert_with(Vec::new);

79+ globs.push(matcher.glob().glob().into());

7680 }

7781 }

7882 map

7983}

8084

81−pub fn list_languages(config: &Config) -> Result<()> {

82− let assets = assets_from_cache_or_binary()?;

85+pub fn get_languages(config: &Config) -> Result<String> {

86+ let mut result: String = String::new();

87+

88+ let assets = assets_from_cache_or_binary(config.use_custom_assets)?;

8389 let mut languages = assets

84− .syntaxes()

90+ .get_syntaxes()?

8591 .iter()

8692 .filter(|syntax| !syntax.hidden && !syntax.file_extensions.is_empty())

8793 .cloned()

8894 .collect::<Vec<_>>();

8995

9096 // Handling of file-extension conflicts, see issue #1076

91− for lang in languages.iter_mut() {

97+ for lang in &mut languages {

9298 let lang_name = lang.name.clone();

9399 lang.file_extensions.retain(|extension| {

94100 // The 'extension' variable is not certainly a real extension.

@@ -97,14 +103,12 @@ pub fn list_languages(config: &Config) -> Result<()> {

97103 // Also skip if the 'extension' contains another real extension, likely

98104 // that is a full match file name like 'CMakeLists.txt' and 'Cargo.lock'

99105 if extension.starts_with('.') || Path::new(extension).extension().is_some() {

100− true

101− } else {

102− let test_file = Path::new("test").with_extension(extension);

103− match assets.syntax_for_file_name(test_file, &config.syntax_mapping) {

104− Some(syntax) => syntax.name == lang_name,

105− None => false,

106− }

106+ return true;

107107 }

108+

109+ let test_file = Path::new("test").with_extension(extension);

110+ let syntax_in_set = assets.get_syntax_for_path(test_file, &config.syntax_mapping);

111+ matches!(syntax_in_set, Ok(syntax_in_set) if syntax_in_set.syntax.name == lang_name)

108112 });

109113 }

110114

@@ -112,19 +116,16 @@ pub fn list_languages(config: &Config) -> Result<()> {

112116

113117 let configured_languages = get_syntax_mapping_to_paths(config.syntax_mapping.mappings());

114118

115− for lang in languages.iter_mut() {

119+ for lang in &mut languages {

116120 if let Some(additional_paths) = configured_languages.get(lang.name.as_str()) {

117121 lang.file_extensions

118122 .extend(additional_paths.iter().cloned());

119123 }

120124 }

121125

122− let stdout = io::stdout();

123− let mut stdout = stdout.lock();

124−

125126 if config.loop_through {

126127 for lang in languages {

127− writeln!(stdout, "{}:{}", lang.name, lang.file_extensions.join(","))?;

128+ result += &format!("{}:{}\n", lang.name, lang.file_extensions.join(","));

128129 }

129130 } else {

130131 let longest = languages

@@ -145,7 +146,7 @@ pub fn list_languages(config: &Config) -> Result<()> {

145146 };

146147

147148 for lang in languages {

148− write!(stdout, "{:width$}{}", lang.name, separator, width = longest)?;

149+ result += &format!("{:width$}{}", lang.name, separator, width = longest);

149150

150151 // Number of characters on this line so far, wrap before `desired_width`

151152 let mut num_chars = 0;

@@ -156,20 +157,20 @@ pub fn list_languages(config: &Config) -> Result<()> {

156157 let new_chars = word.len() + comma_separator.len();

157158 if num_chars + new_chars >= desired_width {

158159 num_chars = 0;

159− write!(stdout, "\n{:width$}{}", "", separator, width = longest)?;

160+ result += &format!("\n{:width$}{}", "", separator, width = longest);

160161 }

161162

162163 num_chars += new_chars;

163− write!(stdout, "{}", style.paint(&word[..]))?;

164+ result += &format!("{}", style.paint(&word[..]));

164165 if extension.peek().is_some() {

165− write!(stdout, "{}", comma_separator)?;

166+ result += comma_separator;

166167 }

167168 }

168− writeln!(stdout)?;

169+ result += "\n";

169170 }

170171 }

171172

172− Ok(())

173+ Ok(result)

173174}

174175

175176fn theme_preview_file<'a>() -> Input<'a> {

@@ -177,7 +178,7 @@ fn theme_preview_file<'a>() -> Input<'a> {

177178}

178179

179180pub fn list_themes(cfg: &Config) -> Result<()> {

180− let assets = assets_from_cache_or_binary()?;

181+ let assets = assets_from_cache_or_binary(cfg.use_custom_assets)?;

181182 let mut config = cfg.clone();

182183 let mut style = HashSet::new();

183184 style.insert(StyleComponent::Plain);

@@ -200,34 +201,97 @@ pub fn list_themes(cfg: &Config) -> Result<()> {

200201 .ok();

201202 writeln!(stdout)?;

202203 }

204+ writeln!(

205+ stdout,

206+ "Further themes can be installed to '{}', \

207+ and are added to the cache with `bat cache --build`. \

208+ For more information, see:\n\n \

209+ https://github.com/sharkdp/bat#adding-new-themes",

210+ PROJECT_DIRS.config_dir().join("themes").to_string_lossy()

211+ )?;

203212 } else {

204213 for theme in assets.themes() {

205214 writeln!(stdout, "{}", theme)?;

206215 }

207216 }

208− writeln!(

209− stdout,

210− "Further themes can be installed to '{}', \

211− and are added to the cache with `bat cache --build`. \

212− For more information, see:\n\n \

213− https://github.com/sharkdp/bat#adding-new-themes",

214− config_file().join("themes").to_string_lossy()

215− )?;

216217

217218 Ok(())

218219}

219220

220221fn run_controller(inputs: Vec<Input>, config: &Config) -> Result<bool> {

221− let assets = assets_from_cache_or_binary()?;

222− let controller = Controller::new(&config, &assets);

222+ let assets = assets_from_cache_or_binary(config.use_custom_assets)?;

223+ let controller = Controller::new(config, &assets);

223224 controller.run(inputs)

224225}

225226

227+#[cfg(feature = "bugreport")]

228+fn invoke_bugreport(app: &App) {

229+ use bugreport::{bugreport, collector::*, format::Markdown};

230+ let pager = bat::config::get_pager_executable(app.matches.value_of("pager"))

231+ .unwrap_or_else(|| "less".to_owned()); // FIXME: Avoid non-canonical path to "less".

232+

233+ let mut custom_assets_metadata = PROJECT_DIRS.cache_dir().to_path_buf();

234+ custom_assets_metadata.push("metadata.yaml");

235+

236+ let mut report = bugreport!()

237+ .info(SoftwareVersion::default())

238+ .info(OperatingSystem::default())

239+ .info(CommandLine::default())

240+ .info(EnvironmentVariables::list(&[

241+ "SHELL",

242+ "PAGER",

243+ "LESS",

244+ "LANG",

245+ "LC_ALL",

246+ "BAT_PAGER",

247+ "BAT_CACHE_PATH",

248+ "BAT_CONFIG_PATH",

249+ "BAT_OPTS",

250+ "BAT_STYLE",

251+ "BAT_TABS",

252+ "BAT_THEME",

253+ "XDG_CONFIG_HOME",

254+ "XDG_CACHE_HOME",

255+ "COLORTERM",

256+ "NO_COLOR",

257+ "MANPAGER",

258+ ]))

259+ .info(FileContent::new("Config file", config_file()))

260+ .info(FileContent::new(

261+ "Custom assets metadata",

262+ custom_assets_metadata,

263+ ))

264+ .info(DirectoryEntries::new(

265+ "Custom assets",

266+ PROJECT_DIRS.cache_dir(),

267+ ))

268+ .info(CompileTimeInformation::default());

269+

270+ #[cfg(feature = "paging")]

271+ if let Ok(resolved_path) = grep_cli::resolve_binary(pager) {

272+ report = report.info(CommandOutput::new(

273+ "Less version",

274+ resolved_path,

275+ &["--version"],

276+ ))

277+ };

278+

279+ report.print::<Markdown>();

280+}

281+

226282/// Returns `Err(..)` upon fatal errors. Otherwise, returns `Ok(true)` on full success and

227283/// `Ok(false)` if any intermediate errors occurred (were printed).

228284fn run() -> Result<bool> {

229285 let app = App::new()?;

230286

287+ if app.matches.is_present("diagnostic") {

288+ #[cfg(feature = "bugreport")]

289+ invoke_bugreport(&app);

290+ #[cfg(not(feature = "bugreport"))]

291+ println!("bat has been built without the 'bugreport' feature. The '--diagnostic' option is not available.");

292+ return Ok(true);

293+ }

294+

231295 match app.matches.subcommand() {

232296 ("cache", Some(cache_matches)) => {

233297 // If there is a file named 'cache' in the current working directory,

@@ -237,7 +301,7 @@ fn run() -> Result<bool> {

237301 run_cache_subcommand(cache_matches)?;

238302 Ok(true)

239303 } else {

240− let inputs = vec![Input::ordinary_file(OsStr::new("cache"))];

304+ let inputs = vec![Input::ordinary_file("cache")];

241305 let config = app.config(&inputs)?;

242306

243307 run_controller(inputs, &config)

@@ -248,8 +312,14 @@ fn run() -> Result<bool> {

248312 let config = app.config(&inputs)?;

249313

250314 if app.matches.is_present("list-languages") {

251− list_languages(&config)?;

252− Ok(true)

315+ let languages: String = get_languages(&config)?;

316+ let inputs: Vec<Input> = vec![Input::from_reader(Box::new(languages.as_bytes()))];

317+ let plain_config = Config {

318+ style_components: StyleComponents::new(StyleComponent::Plain.components(false)),

319+ paging_mode: PagingMode::QuitIfOneScreen,

320+ ..Default::default()

321+ };

322+ run_controller(inputs, &plain_config)

253323 } else if app.matches.is_present("list-themes") {

254324 list_themes(&config)?;

255325 Ok(true)

@@ -265,6 +335,9 @@ fn run() -> Result<bool> {

265335 } else if app.matches.is_present("cache-dir") {

266336 writeln!(io::stdout(), "{}", cache_dir())?;

267337 Ok(true)

338+ } else if app.matches.is_present("acknowledgements") {

339+ writeln!(io::stdout(), "{}", bat::assets::get_acknowledgements())?;

340+ Ok(true)

268341 } else {

269342 run_controller(inputs, &config)

270343 }

src/config.rs+12

@@ -82,6 +82,18 @@ pub struct Config<'a> {

8282

8383 /// Ranges of lines which should be highlighted with a special background color

8484 pub highlighted_lines: HighlightedLineRanges,

85+

86+ /// Whether or not to allow custom assets. If this is false or if custom assets (a.k.a.

87+ /// cached assets) are not available, assets from the binary will be used instead.

88+ pub use_custom_assets: bool,

89+}

90+

91+#[cfg(all(feature = "minimal-application", feature = "paging"))]

92+pub fn get_pager_executable(config_pager: Option<&str>) -> Option<String> {

93+ crate::pager::get_pager(config_pager)

94+ .ok()

95+ .flatten()

96+ .map(|pager| pager.bin)

8597}

8698

8799#[test]

src/controller.rs+91−74

@@ -1,4 +1,4 @@

1−use std::io::{self, Write};

1+use std::io::{self, BufRead, Write};

33use crate::assets::HighlightingAssets;

44use crate::config::{Config, VisibleLines};

@@ -14,6 +14,8 @@ use crate::output::OutputType;

1414use crate::paging::PagingMode;

1515use crate::printer::{InteractivePrinter, Printer, SimplePrinter};

1616

17+use clircle::{Clircle, Identifier};

18+

1719pub struct Controller<'a> {

1820 config: &'a Config<'a>,

1921 assets: &'a HighlightingAssets,

@@ -43,7 +45,7 @@ impl<'b> Controller<'b> {

4345 // Do not launch the pager if NONE of the input files exist

4446 let mut paging_mode = self.config.paging_mode;

4547 if self.config.paging_mode != PagingMode::Never {

46− let call_pager = inputs.iter().any(|ref input| {

48+ let call_pager = inputs.iter().any(|input| {

4749 if let InputKind::OrdinaryFile(ref path) = input.kind {

4850 Path::new(path).exists()

4951 } else {

@@ -66,85 +68,97 @@ impl<'b> Controller<'b> {

6668 }

6769

6870 let attached_to_pager = output_type.is_pager();

71+ let stdout_identifier = if cfg!(windows) || attached_to_pager {

72+ None

73+ } else {

74+ clircle::Identifier::stdout()

75+ };

76+

6977 let writer = output_type.handle()?;

7078 let mut no_errors: bool = true;

71−

7279 let stderr = io::stderr();

73− let print_error = |error: &Error, write: &mut dyn Write| {

74− if attached_to_pager {

75− handle_error(error, write);

76− } else {

77− handle_error(error, &mut stderr.lock());

78− }

79− };

8080

8181 for (index, input) in inputs.into_iter().enumerate() {

82− match input.open(io::stdin().lock()) {

83− Err(error) => {

84− print_error(&error, writer);

85− no_errors = false;

82+ let identifier = stdout_identifier.as_ref();

83+ let is_first = index == 0;

84+ let result = if input.is_stdin() {

85+ self.print_input(input, writer, io::stdin().lock(), identifier, is_first)

86+ } else {

87+ // Use dummy stdin since stdin is actually not used (#1902)

88+ self.print_input(input, writer, io::empty(), identifier, is_first)

89+ };

90+ if let Err(error) = result {

91+ if attached_to_pager {

92+ handle_error(&error, writer);

93+ } else {

94+ handle_error(&error, &mut stderr.lock());

8695 }

87− Ok(mut opened_input) => {

88− #[cfg(feature = "git")]

89− let line_changes = if self.config.visible_lines.diff_mode()

90− || (!self.config.loop_through && self.config.style_components.changes())

91− {

92− match opened_input.kind {

93− crate::input::OpenedInputKind::OrdinaryFile(ref path) => {

94− let diff = get_git_diff(path);

95−

96− // Skip files without Git modifications

97− if self.config.visible_lines.diff_mode()

98− && diff

99− .as_ref()

100− .map(|changes| changes.is_empty())

101− .unwrap_or(false)

102− {

103− continue;

104− }

105−

106− diff

107− }

108− _ if self.config.visible_lines.diff_mode() => {

109− // Skip non-file inputs in diff mode

110− continue;

111− }

112− _ => None,

113− }

114− } else {

115− None

116− };

96+ no_errors = false;

97+ }

98+ }

11799

118− let mut printer: Box<dyn Printer> = if self.config.loop_through {

119− Box::new(SimplePrinter::new(&self.config))

120− } else {

121− Box::new(InteractivePrinter::new(

122− &self.config,

123− &self.assets,

124− &mut opened_input,

125− #[cfg(feature = "git")]

126− &line_changes,

127− )?)

128− };

129−

130− let result = self.print_file(

131− &mut *printer,

132− writer,

133− &mut opened_input,

134− index != 0,

135− #[cfg(feature = "git")]

136− &line_changes,

137− );

138−

139− if let Err(error) = result {

140− print_error(&error, writer);

141− no_errors = false;

100+ Ok(no_errors)

101+ }

102+

103+ fn print_input<R: BufRead>(

104+ &self,

105+ input: Input,

106+ writer: &mut dyn Write,

107+ stdin: R,

108+ stdout_identifier: Option<&Identifier>,

109+ is_first: bool,

110+ ) -> Result<()> {

111+ let mut opened_input = input.open(stdin, stdout_identifier)?;

112+ #[cfg(feature = "git")]

113+ let line_changes = if self.config.visible_lines.diff_mode()

114+ || (!self.config.loop_through && self.config.style_components.changes())

115+ {

116+ match opened_input.kind {

117+ crate::input::OpenedInputKind::OrdinaryFile(ref path) => {

118+ let diff = get_git_diff(path);

119+

120+ // Skip files without Git modifications

121+ if self.config.visible_lines.diff_mode()

122+ && diff

123+ .as_ref()

124+ .map(|changes| changes.is_empty())

125+ .unwrap_or(false)

126+ {

127+ return Ok(());

142128 }

129+

130+ diff

143131 }

132+ _ if self.config.visible_lines.diff_mode() => {

133+ // Skip non-file inputs in diff mode

134+ return Ok(());

135+ }

136+ _ => None,

144137 }

145− }

138+ } else {

139+ None

140+ };

146141

147− Ok(no_errors)

142+ let mut printer: Box<dyn Printer> = if self.config.loop_through {

143+ Box::new(SimplePrinter::new(self.config))

144+ } else {

145+ Box::new(InteractivePrinter::new(

146+ self.config,

147+ self.assets,

148+ &mut opened_input,

149+ #[cfg(feature = "git")]

150+ &line_changes,

151+ )?)

152+ };

153+

154+ self.print_file(

155+ &mut *printer,

156+ writer,

157+ &mut opened_input,

158+ !is_first,

159+ #[cfg(feature = "git")]

160+ &line_changes,

161+ )

148162 }

149163

150164 fn print_file(

@@ -167,9 +181,10 @@ impl<'b> Controller<'b> {

167181 let mut line_ranges: Vec<LineRange> = vec![];

168182

169183 if let Some(line_changes) = line_changes {

170− for line in line_changes.keys() {

171− let line = *line as usize;

172− line_ranges.push(LineRange::new(line - context, line + context));

184+ for &line in line_changes.keys() {

185+ let line = line as usize;

186+ line_ranges

187+ .push(LineRange::new(line.saturating_sub(context), line + context));

173188 }

174189 }

175190

@@ -197,6 +212,8 @@ impl<'b> Controller<'b> {

197212 let mut first_range: bool = true;

198213 let mut mid_range: bool = false;

199214

215+ let style_snip = self.config.style_components.snip();

216+

200217 while reader.read_line(&mut line_buffer)? {

201218 match line_ranges.check(line_number) {

202219 RangeCheckResult::BeforeOrBetweenRanges => {

@@ -207,7 +224,7 @@ impl<'b> Controller<'b> {

207224 }

208225

209226 RangeCheckResult::InRange => {

210− if self.config.style_components.snip() {

227+ if style_snip {

211228 if first_range {

212229 first_range = false;

213230 mid_range = true;

src/diff.rs+1−2

@@ -1,7 +1,6 @@

11#![cfg(feature = "git")]

33use std::collections::HashMap;

4−use std::ffi::OsStr;

54use std::fs;

65use std::path::Path;

@@ -17,7 +16,7 @@ pub enum LineChange {

1716

1817pub type LineChanges = HashMap<u32, LineChange>;

1918

20−pub fn get_git_diff(filename: &OsStr) -> Option<LineChanges> {

19+pub fn get_git_diff(filename: &Path) -> Option<LineChanges> {

2120 let repo = Repository::discover(&filename).ok()?;

2221

2322 let repo_path_absolute = fs::canonicalize(repo.workdir()?).ok()?;

src/error.rs+39−26

@@ -1,42 +1,55 @@

1−use error_chain::error_chain;

21use std::io::Write;

2+use thiserror::Error;

4−error_chain! {

5− foreign_links {

6− Clap(::clap::Error) #[cfg(feature = "application")];

7− Io(::std::io::Error);

8− SyntectError(::syntect::LoadingError);

9− ParseIntError(::std::num::ParseIntError);

10− GlobParsingError(::globset::Error);

11− SerdeYamlError(::serde_yaml::Error);

4+#[derive(Error, Debug)]

5+#[non_exhaustive]

6+pub enum Error {

7+ #[error(transparent)]

8+ Io(#[from] ::std::io::Error),

9+ #[error(transparent)]

10+ SyntectError(#[from] ::syntect::Error),

11+ #[error(transparent)]

12+ SyntectLoadingError(#[from] ::syntect::LoadingError),

13+ #[error(transparent)]

14+ ParseIntError(#[from] ::std::num::ParseIntError),

15+ #[error(transparent)]

16+ GlobParsingError(#[from] ::globset::Error),

17+ #[error(transparent)]

18+ SerdeYamlError(#[from] ::serde_yaml::Error),

19+ #[error("unable to detect syntax for {0}")]

20+ UndetectedSyntax(String),

21+ #[error("unknown syntax: '{0}'")]

22+ UnknownSyntax(String),

23+ #[error("Unknown style '{0}'")]

24+ UnknownStyle(String),

25+ #[error("Use of bat as a pager is disallowed in order to avoid infinite recursion problems")]

26+ InvalidPagerValueBat,

27+ #[error("{0}")]

28+ Msg(String),

29+}

30+

31+impl From<&'static str> for Error {

32+ fn from(s: &'static str) -> Self {

33+ Error::Msg(s.to_owned())

1234 }

35+}

1336

14− errors {

15− UndetectedSyntax(input: String) {

16− description("unable to detect syntax"),

17− display("unable to detect syntax for {}", input)

18− }

19− UnknownSyntax(name: String) {

20− description("unknown syntax"),

21− display("unknown syntax: '{}'", name)

22− }

23− InvalidPagerValueBat {

24− description("invalid value `bat` for pager property"),

25− display("Use of bat as a pager is disallowed in order to avoid infinite recursion problems")

26− }

37+impl From<String> for Error {

38+ fn from(s: String) -> Self {

39+ Error::Msg(s)

2740 }

2841}

2942

43+pub type Result<T> = std::result::Result<T, Error>;

44+

3045pub fn default_error_handler(error: &Error, output: &mut dyn Write) {

3146 use ansi_term::Colour::Red;

3247

3348 match error {

34− Error(ErrorKind::Io(ref io_error), _)

35− if io_error.kind() == ::std::io::ErrorKind::BrokenPipe =>

36− {

49+ Error::Io(ref io_error) if io_error.kind() == ::std::io::ErrorKind::BrokenPipe => {

3750 ::std::process::exit(0);

3851 }

39− Error(ErrorKind::SerdeYamlError(_), _) => {

52+ Error::SerdeYamlError(_) => {

4053 writeln!(

4154 output,

4255 "{}: Error while parsing metadata.yaml file: {}",

src/input.rs+96−38

@@ -1,7 +1,10 @@

1−use std::ffi::{OsStr, OsString};

1+use std::convert::TryFrom;

2+use std::fs;

23use std::fs::File;

34use std::io::{self, BufRead, BufReader, Read};

5+use std::path::{Path, PathBuf};

7+use clircle::{Clircle, Identifier};

58use content_inspector::{self, ContentType};

710use crate::error::*;

@@ -48,8 +51,8 @@ impl InputDescription {

4851 }

4952

5053 pub fn title(&self) -> &String {

51− match self.title.as_ref() {

52− Some(ref title) => title,

54+ match &self.title {

55+ Some(title) => title,

5356 None => &self.name,

5457 }

5558 }

@@ -67,7 +70,7 @@ impl InputDescription {

6770}

6871

6972pub(crate) enum InputKind<'a> {

70− OrdinaryFile(OsString),

73+ OrdinaryFile(PathBuf),

7174 StdIn,

7275 CustomReader(Box<dyn Read + 'a>),

7376}

@@ -84,7 +87,8 @@ impl<'a> InputKind<'a> {

8487

8588#[derive(Clone, Default)]

8689pub(crate) struct InputMetadata {

87− pub(crate) user_provided_name: Option<OsString>,

90+ pub(crate) user_provided_name: Option<PathBuf>,

91+ pub(crate) size: Option<u64>,

8892}

8993

9094pub struct Input<'a> {

@@ -94,7 +98,7 @@ pub struct Input<'a> {

9498}

9599

96100pub(crate) enum OpenedInputKind {

97− OrdinaryFile(OsString),

101+ OrdinaryFile(PathBuf),

98102 StdIn,

99103 CustomReader,

100104}

@@ -106,12 +110,36 @@ pub(crate) struct OpenedInput<'a> {

106110 pub(crate) description: InputDescription,

107111}

108112

113+impl OpenedInput<'_> {

114+ /// Get the path of the file:

115+ /// If this was set by the metadata, that will take priority.

116+ /// If it wasn't, it will use the real file path (if available).

117+ pub(crate) fn path(&self) -> Option<&PathBuf> {

118+ self.metadata

119+ .user_provided_name

120+ .as_ref()

121+ .or(match self.kind {

122+ OpenedInputKind::OrdinaryFile(ref path) => Some(path),

123+ _ => None,

124+ })

125+ }

126+}

127+

109128impl<'a> Input<'a> {

110− pub fn ordinary_file(path: &OsStr) -> Self {

111− let kind = InputKind::OrdinaryFile(path.to_os_string());

129+ pub fn ordinary_file(path: impl AsRef<Path>) -> Self {

130+ Self::_ordinary_file(path.as_ref())

131+ }

132+

133+ fn _ordinary_file(path: &Path) -> Self {

134+ let kind = InputKind::OrdinaryFile(path.to_path_buf());

135+ let metadata = InputMetadata {

136+ size: fs::metadata(path).map(|m| m.len()).ok(),

137+ ..InputMetadata::default()

138+ };

139+

112140 Input {

113141 description: kind.description(),

114− metadata: InputMetadata::default(),

142+ metadata,

115143 kind,

116144 }

117145 }

@@ -135,14 +163,14 @@ impl<'a> Input<'a> {

135163 }

136164

137165 pub fn is_stdin(&self) -> bool {

138− if let InputKind::StdIn = self.kind {

139− true

140− } else {

141− false

142− }

166+ matches!(self.kind, InputKind::StdIn)

143167 }

144168

145− pub fn with_name(mut self, provided_name: Option<&OsStr>) -> Self {

169+ pub fn with_name(self, provided_name: Option<impl AsRef<Path>>) -> Self {

170+ self._with_name(provided_name.as_ref().map(|it| it.as_ref()))

171+ }

172+

173+ fn _with_name(mut self, provided_name: Option<&Path>) -> Self {

146174 if let Some(name) = provided_name {

147175 self.description.name = name.to_string_lossy().to_string()

148176 }

@@ -159,25 +187,55 @@ impl<'a> Input<'a> {

159187 &mut self.description

160188 }

161189

162− pub(crate) fn open<R: BufRead + 'a>(self, stdin: R) -> Result<OpenedInput<'a>> {

190+ pub(crate) fn open<R: BufRead + 'a>(

191+ self,

192+ stdin: R,

193+ stdout_identifier: Option<&Identifier>,

194+ ) -> Result<OpenedInput<'a>> {

163195 let description = self.description().clone();

164196 match self.kind {

165− InputKind::StdIn => Ok(OpenedInput {

166− kind: OpenedInputKind::StdIn,

167− description,

168− metadata: self.metadata,

169− reader: InputReader::new(stdin),

170− }),

197+ InputKind::StdIn => {

198+ if let Some(stdout) = stdout_identifier {

199+ let input_identifier = Identifier::try_from(clircle::Stdio::Stdin)

200+ .map_err(|e| format!("Stdin: Error identifying file: {}", e))?;

201+ if stdout.surely_conflicts_with(&input_identifier) {

202+ return Err("IO circle detected. The input from stdin is also an output. Aborting to avoid infinite loop.".into());

203+ }

204+ }

205+

206+ Ok(OpenedInput {

207+ kind: OpenedInputKind::StdIn,

208+ description,

209+ metadata: self.metadata,

210+ reader: InputReader::new(stdin),

211+ })

212+ }

213+

171214 InputKind::OrdinaryFile(path) => Ok(OpenedInput {

172215 kind: OpenedInputKind::OrdinaryFile(path.clone()),

173216 description,

174217 metadata: self.metadata,

175218 reader: {

176− let file = File::open(&path)

219+ let mut file = File::open(&path)

177220 .map_err(|e| format!("'{}': {}", path.to_string_lossy(), e))?;

178221 if file.metadata()?.is_dir() {

179222 return Err(format!("'{}' is a directory.", path.to_string_lossy()).into());

180223 }

224+

225+ if let Some(stdout) = stdout_identifier {

226+ let input_identifier = Identifier::try_from(file).map_err(|e| {

227+ format!("{}: Error identifying file: {}", path.to_string_lossy(), e)

228+ })?;

229+ if stdout.surely_conflicts_with(&input_identifier) {

230+ return Err(format!(

231+ "IO circle detected. The input from '{}' is also an output. Aborting to avoid infinite loop.",

232+ path.to_string_lossy()

233+ )

234+ .into());

235+ }

236+ file = input_identifier.into_inner().expect("The file was lost in the clircle::Identifier, this should not have happened...");

237+ }

238+

181239 InputReader::new(BufReader::new(file))

182240 },

183241 }),

@@ -220,18 +278,18 @@ impl<'a> InputReader<'a> {

220278 }

221279

222280 pub(crate) fn read_line(&mut self, buf: &mut Vec<u8>) -> io::Result<bool> {

223− if self.first_line.is_empty() {

224− let res = self.inner.read_until(b'\n', buf).map(|size| size > 0)?;

281+ if !self.first_line.is_empty() {

282+ buf.append(&mut self.first_line);

283+ return Ok(true);

284+ }

225285

226− if self.content_type == Some(ContentType::UTF_16LE) {

227− self.inner.read_until(0x00, buf).ok();

228− }

286+ let res = self.inner.read_until(b'\n', buf).map(|size| size > 0)?;

229287

230− Ok(res)

231− } else {

232− buf.append(&mut self.first_line);

233− Ok(true)

288+ if self.content_type == Some(ContentType::UTF_16LE) {

289+ let _ = self.inner.read_until(0x00, buf);

234290 }

291+

292+ Ok(res)

235293 }

236294}

237295

@@ -246,21 +304,21 @@ fn basic() {

246304

247305 let res = reader.read_line(&mut buffer);

248306 assert!(res.is_ok());

249− assert_eq!(true, res.unwrap());

307+ assert!(res.unwrap());

250308 assert_eq!(b"#!/bin/bash\n", &buffer[..]);

251309

252310 buffer.clear();

253311

254312 let res = reader.read_line(&mut buffer);

255313 assert!(res.is_ok());

256− assert_eq!(true, res.unwrap());

314+ assert!(res.unwrap());

257315 assert_eq!(b"echo hello", &buffer[..]);

258316

259317 buffer.clear();

260318

261319 let res = reader.read_line(&mut buffer);

262320 assert!(res.is_ok());

263− assert_eq!(false, res.unwrap());

321+ assert!(!res.unwrap());

264322 assert!(buffer.is_empty());

265323}

266324

@@ -275,20 +333,20 @@ fn utf16le() {

275333

276334 let res = reader.read_line(&mut buffer);

277335 assert!(res.is_ok());

278− assert_eq!(true, res.unwrap());

336+ assert!(res.unwrap());

279337 assert_eq!(b"\xFF\xFE\x73\x00\x0A\x00", &buffer[..]);

280338

281339 buffer.clear();

282340

283341 let res = reader.read_line(&mut buffer);

284342 assert!(res.is_ok());

285− assert_eq!(true, res.unwrap());

343+ assert!(res.unwrap());

286344 assert_eq!(b"\x64\x00", &buffer[..]);

287345

288346 buffer.clear();

289347

290348 let res = reader.read_line(&mut buffer);

291349 assert!(res.is_ok());

292− assert_eq!(false, res.unwrap());

350+ assert!(!res.unwrap());

293351 assert!(buffer.is_empty());

294352}

src/less.rs+79−12

@@ -1,19 +1,39 @@

11#![cfg(feature = "paging")]

3+use std::ffi::OsStr;

34use std::process::Command;

5−pub fn retrieve_less_version() -> Option<usize> {

6− let cmd = Command::new("less").arg("--version").output().ok()?;

7− parse_less_version(&cmd.stdout)

6+#[derive(Debug, PartialEq)]

7+pub enum LessVersion {

8+ Less(usize),

9+ BusyBox,

810}

911

10−fn parse_less_version(output: &[u8]) -> Option<usize> {

11− if output.starts_with(b"less ") {

12− let version = std::str::from_utf8(&output[5..]).ok()?;

13− let end = version.find(' ')?;

14− version[..end].parse::<usize>().ok()

12+pub fn retrieve_less_version(less_path: &dyn AsRef<OsStr>) -> Option<LessVersion> {

13+ let resolved_path = grep_cli::resolve_binary(less_path.as_ref()).ok()?;

14+

15+ let cmd = Command::new(resolved_path).arg("--version").output().ok()?;

16+ if cmd.status.success() {

17+ parse_less_version(&cmd.stdout)

1518 } else {

16− None

19+ parse_less_version_busybox(&cmd.stderr)

20+ }

21+}

22+

23+fn parse_less_version(output: &[u8]) -> Option<LessVersion> {

24+ if !output.starts_with(b"less ") {

25+ return None;

26+ }

27+

28+ let version = std::str::from_utf8(&output[5..]).ok()?;

29+ let end = version.find(|c: char| !c.is_ascii_digit())?;

30+ Some(LessVersion::Less(version[..end].parse::<usize>().ok()?))

31+}

32+

33+fn parse_less_version_busybox(output: &[u8]) -> Option<LessVersion> {

34+ match std::str::from_utf8(output) {

35+ Ok(version) if version.contains("BusyBox ") => Some(LessVersion::BusyBox),

36+ _ => None,

1737 }

1838}

1939

@@ -27,7 +47,7 @@ For information about the terms of redistribution,

2747see the file named README in the less distribution.

2848Homepage: http://www.greenwoodsoftware.com/less";

2949

30− assert_eq!(Some(487), parse_less_version(output));

50+ assert_eq!(Some(LessVersion::Less(487)), parse_less_version(output));

3151}

3252

3353#[test]

@@ -40,7 +60,7 @@ For information about the terms of redistribution,

4060see the file named README in the less distribution.

4161Homepage: http://www.greenwoodsoftware.com/less";

4262

43− assert_eq!(Some(529), parse_less_version(output));

63+ assert_eq!(Some(LessVersion::Less(529)), parse_less_version(output));

4464}

4565

4666#[test]

@@ -53,7 +73,20 @@ For information about the terms of redistribution,

5373see the file named README in the less distribution.

5474Home page: http://www.greenwoodsoftware.com/less";

5575

56− assert_eq!(Some(551), parse_less_version(output));

76+ assert_eq!(Some(LessVersion::Less(551)), parse_less_version(output));

77+}

78+

79+#[test]

80+fn test_parse_less_version_581_2() {

81+ let output = b"less 581.2 (PCRE2 regular expressions)

83+

84+less comes with NO WARRANTY, to the extent permitted by law.

85+For information about the terms of redistribution,

86+see the file named README in the less distribution.

87+Home page: https://greenwoodsoftware.com/less";

88+

89+ assert_eq!(Some(LessVersion::Less(581)), parse_less_version(output));

5790}

5891

5992#[test]

@@ -61,4 +94,38 @@ fn test_parse_less_version_wrong_program() {

6194 let output = b"more from util-linux 2.34";

6295

6396 assert_eq!(None, parse_less_version(output));

97+ assert_eq!(None, parse_less_version_busybox(output));

98+}

99+

100+#[test]

101+fn test_parse_less_version_busybox() {

102+ let output = b"pkg/less: unrecognized option '--version'

103+BusyBox v1.35.0 (2022-04-21 10:38:11 EDT) multi-call binary.

104+

105+Usage: less [-EFIMmNSRh~] [FILE]...

106+

107+View FILE (or stdin) one screenful at a time

108+

109+ -E Quit once the end of a file is reached

110+ -F Quit if entire file fits on first screen

111+ -I Ignore case in all searches

112+ -M,-m Display status line with line numbers

113+ and percentage through the file

114+ -N Prefix line number to each line

115+ -S Truncate long lines

116+ -R Remove color escape codes in input

117+ -~ Suppress ~s displayed past EOF";

118+

119+ assert_eq!(

120+ Some(LessVersion::BusyBox),

121+ parse_less_version_busybox(output)

122+ );

123+}

124+

125+#[test]

126+fn test_parse_less_version_invalid_utf_8() {

127+ let output = b"\xff";

128+

129+ assert_eq!(None, parse_less_version(output));

130+ assert_eq!(None, parse_less_version_busybox(output));

64131}

src/lib.rs+10−1

@@ -19,8 +19,14 @@

1919//! .unwrap();

2020//! ```

2121

22+#![deny(unsafe_code)]

23+

24+mod macros;

25+

2226pub mod assets;

23−pub mod assets_metadata;

27+pub mod assets_metadata {

28+ pub use super::assets::assets_metadata::*;

29+}

2430pub mod config;

2531pub mod controller;

2632mod decorations;

@@ -31,6 +37,8 @@ mod less;

3137pub mod line_range;

3238mod output;

3339#[cfg(feature = "paging")]

40+mod pager;

41+#[cfg(feature = "paging")]

3442pub(crate) mod paging;

3543mod preprocessor;

3644mod pretty_printer;

@@ -38,6 +46,7 @@ pub(crate) mod printer;

3846pub mod style;

3947pub(crate) mod syntax_mapping;

4048mod terminal;

49+mod vscreen;

4150pub(crate) mod wrapping;

4251

4352pub use pretty_printer::{Input, PrettyPrinter};

src/line_range.rs+69−1

@@ -47,7 +47,28 @@ impl LineRange {

4747 }

4848 2 => {

4949 new_range.lower = line_numbers[0].parse()?;

50− new_range.upper = line_numbers[1].parse()?;

50+ let first_byte = line_numbers[1].bytes().next();

51+

52+ new_range.upper = if first_byte == Some(b'+') {

53+ let more_lines = &line_numbers[1][1..]

54+ .parse()

55+ .map_err(|_| "Invalid character after +")?;

56+ new_range.lower + more_lines

57+ } else if first_byte == Some(b'-') {

58+ // this will prevent values like "-+5" even though "+5" is valid integer

59+ if line_numbers[1][1..].bytes().next() == Some(b'+') {

60+ return Err("Invalid character after -".into());

61+ }

62+ let prior_lines = &line_numbers[1][1..]

63+ .parse()

64+ .map_err(|_| "Invalid character after -")?;

65+ let prev_lower = new_range.lower;

66+ new_range.lower = new_range.lower.saturating_sub(*prior_lines);

67+ prev_lower

68+ } else {

69+ line_numbers[1].parse()?

70+ };

71+

5172 Ok(new_range)

5273 }

5374 _ => Err(

@@ -100,6 +121,53 @@ fn test_parse_fail() {

100121 assert!(range.is_err());

101122}

102123

124+#[test]

125+fn test_parse_plus() {

126+ let range = LineRange::from("40:+10").expect("Shouldn't fail on test!");

127+ assert_eq!(40, range.lower);

128+ assert_eq!(50, range.upper);

129+}

130+

131+#[test]

132+fn test_parse_plus_fail() {

133+ let range = LineRange::from("40:+z");

134+ assert!(range.is_err());

135+ let range = LineRange::from("40:+-10");

136+ assert!(range.is_err());

137+ let range = LineRange::from("40:+");

138+ assert!(range.is_err());

139+}

140+

141+#[test]

142+fn test_parse_minus_success() {

143+ let range = LineRange::from("40:-10").expect("Shouldn't fail on test!");

144+ assert_eq!(30, range.lower);

145+ assert_eq!(40, range.upper);

146+}

147+

148+#[test]

149+fn test_parse_minus_edge_cases_success() {

150+ let range = LineRange::from("5:-4").expect("Shouldn't fail on test!");

151+ assert_eq!(1, range.lower);

152+ assert_eq!(5, range.upper);

153+ let range = LineRange::from("5:-5").expect("Shouldn't fail on test!");

154+ assert_eq!(0, range.lower);

155+ assert_eq!(5, range.upper);

156+ let range = LineRange::from("5:-100").expect("Shouldn't fail on test!");

157+ assert_eq!(0, range.lower);

158+ assert_eq!(5, range.upper);

159+}

160+

161+#[test]

162+fn test_parse_minus_fail() {

163+ let range = LineRange::from("40:-z");

164+ assert!(range.is_err());

165+ let range = LineRange::from("40:-+10");

166+ assert!(range.is_err());

167+ let range = LineRange::from("40:-");

168+ assert!(range.is_err());

169+}

170+

103171#[derive(Copy, Clone, Debug, PartialEq)]

104172pub enum RangeCheckResult {

105173 // Within one of the given ranges

src/macros.rsnew file+7

@@ -0,0 +1,7 @@

1+#[macro_export]

2+macro_rules! bat_warning {

3+ ($($arg:tt)*) => ({

4+ use ansi_term::Colour::Yellow;

5+ eprintln!("{}: {}", Yellow.paint("[bat warning]"), format!($($arg)*));

6+ })

7+}

src/output.rs+64−88

@@ -4,7 +4,7 @@ use std::process::Child;

55use crate::error::*;

66#[cfg(feature = "paging")]

7−use crate::less::retrieve_less_version;

7+use crate::less::{retrieve_less_version, LessVersion};

88#[cfg(feature = "paging")]

99use crate::paging::PagingMode;

1010#[cfg(feature = "paging")]

@@ -48,100 +48,80 @@ impl OutputType {

4848 wrapping_mode: WrappingMode,

4949 pager_from_config: Option<&str>,

5050 ) -> Result<Self> {

51− use std::env;

52− use std::ffi::OsString;

53− use std::path::PathBuf;

51+ use crate::pager::{self, PagerKind, PagerSource};

5452 use std::process::{Command, Stdio};

5553

56− let mut replace_arguments_to_less = false;

54+ let pager_opt =

55+ pager::get_pager(pager_from_config).map_err(|_| "Could not parse pager command.")?;

5756

58− let pager_from_env = match (env::var("BAT_PAGER"), env::var("PAGER")) {

59− (Ok(bat_pager), _) => Some(bat_pager),

60− (_, Ok(pager)) => {

61− // less needs to be called with the '-R' option in order to properly interpret the

62− // ANSI color sequences printed by bat. If someone has set PAGER="less -F", we

63− // therefore need to overwrite the arguments and add '-R'.

64− //

65− // We only do this for PAGER (as it is not specific to 'bat'), not for BAT_PAGER

66− // or bats '--pager' command line option.

67− replace_arguments_to_less = true;

68− Some(pager)

69− }

70− _ => None,

57+ let pager = match pager_opt {

58+ Some(pager) => pager,

59+ None => return Ok(OutputType::stdout()),

7160 };

7261

73− let pager_from_config = pager_from_config.map(|p| p.to_string());

74−

75− if pager_from_config.is_some() {

76− replace_arguments_to_less = false;

62+ if pager.kind == PagerKind::Bat {

63+ return Err(Error::InvalidPagerValueBat);

7764 }

7865

79− let pager = pager_from_config

80− .or(pager_from_env)

81− .unwrap_or_else(|| String::from("less"));

82−

83− let pagerflags =

84− shell_words::split(&pager).chain_err(|| "Could not parse pager command.")?;

66+ let resolved_path = match grep_cli::resolve_binary(&pager.bin) {

67+ Ok(path) => path,

68+ Err(_) => {

69+ return Ok(OutputType::stdout());

70+ }

71+ };

8572

86− match pagerflags.split_first() {

87− Some((pager_name, args)) => {

88− let pager_path = PathBuf::from(pager_name);

73+ let mut p = Command::new(resolved_path);

74+ let args = pager.args;

75+

76+ if pager.kind == PagerKind::Less {

77+ // less needs to be called with the '-R' option in order to properly interpret the

78+ // ANSI color sequences printed by bat. If someone has set PAGER="less -F", we

79+ // therefore need to overwrite the arguments and add '-R'.

80+ //

81+ // We only do this for PAGER (as it is not specific to 'bat'), not for BAT_PAGER

82+ // or bats '--pager' command line option.

83+ let replace_arguments_to_less = pager.source == PagerSource::EnvVarPager;

84+

85+ if args.is_empty() || replace_arguments_to_less {

86+ p.arg("-R"); // Short version of --RAW-CONTROL-CHARS for maximum compatibility

87+ if single_screen_action == SingleScreenAction::Quit {

88+ p.arg("-F"); // Short version of --quit-if-one-screen for compatibility

89+ }

8990

90− if pager_path.file_stem() == Some(&OsString::from("bat")) {

91− return Err(ErrorKind::InvalidPagerValueBat.into());

91+ if wrapping_mode == WrappingMode::NoWrapping(true) {

92+ p.arg("-S"); // Short version of --chop-long-lines for compatibility

9293 }

9394

94− let is_less = pager_path.file_stem() == Some(&OsString::from("less"));

95−

96− let mut process = if is_less {

97− let mut p = Command::new(&pager_path);

98− if args.is_empty() || replace_arguments_to_less {

99− p.arg("--RAW-CONTROL-CHARS");

100− if single_screen_action == SingleScreenAction::Quit {

101− p.arg("--quit-if-one-screen");

102− }

103−

104− if wrapping_mode == WrappingMode::NoWrapping {

105− p.arg("--chop-long-lines");

106− }

107−

108− // Passing '--no-init' fixes a bug with '--quit-if-one-screen' in older

109− // versions of 'less'. Unfortunately, it also breaks mouse-wheel support.

110− //

111− // See: http://www.greenwoodsoftware.com/less/news.530.html

112− //

113− // For newer versions (530 or 558 on Windows), we omit '--no-init' as it

114− // is not needed anymore.

115− match retrieve_less_version() {

116− None => {

117− p.arg("--no-init");

118− }

119− Some(version)

120− if (version < 530 || (cfg!(windows) && version < 558)) =>

121− {

122− p.arg("--no-init");

123− }

124− _ => {}

125− }

126− } else {

127− p.args(args);

95+ // Passing '--no-init' fixes a bug with '--quit-if-one-screen' in older

96+ // versions of 'less'. Unfortunately, it also breaks mouse-wheel support.

97+ //

98+ // See: http://www.greenwoodsoftware.com/less/news.530.html

99+ //

100+ // For newer versions (530 or 558 on Windows), we omit '--no-init' as it

101+ // is not needed anymore.

102+ match retrieve_less_version(&pager.bin) {

103+ None => {

104+ p.arg("--no-init");

128105 }

129− p.env("LESSCHARSET", "UTF-8");

130− p

131− } else {

132− let mut p = Command::new(&pager_path);

133− p.args(args);

134− p

135− };

136−

137− Ok(process

138− .stdin(Stdio::piped())

139− .spawn()

140− .map(OutputType::Pager)

141− .unwrap_or_else(|_| OutputType::stdout()))

106+ Some(LessVersion::Less(version))

107+ if (version < 530 || (cfg!(windows) && version < 558)) =>

108+ {

109+ p.arg("--no-init");

110+ }

111+ _ => {}

112+ }

113+ } else {

114+ p.args(args);

142115 }

143− None => Ok(OutputType::stdout()),

144− }

116+ p.env("LESSCHARSET", "UTF-8");

117+ } else {

118+ p.args(args);

119+ };

120+

121+ Ok(p.stdin(Stdio::piped())

122+ .spawn()

123+ .map(OutputType::Pager)

124+ .unwrap_or_else(|_| OutputType::stdout()))

145125 }

146126

147127 pub(crate) fn stdout() -> Self {

@@ -150,11 +130,7 @@ impl OutputType {

150130

151131 #[cfg(feature = "paging")]

152132 pub(crate) fn is_pager(&self) -> bool {

153− if let OutputType::Pager(_) = self {

154− true

155− } else {

156− false

157− }

133+ matches!(self, OutputType::Pager(_))

158134 }

159135

160136 #[cfg(not(feature = "paging"))]

@@ -168,7 +144,7 @@ impl OutputType {

168144 OutputType::Pager(ref mut command) => command

169145 .stdin

170146 .as_mut()

171− .chain_err(|| "Could not open stdin for pager")?,

147+ .ok_or("Could not open stdin for pager")?,

172148 OutputType::Stdout(ref mut handle) => handle,

173149 })

174150 }

src/pager.rsnew file+123

@@ -0,0 +1,123 @@

1+use shell_words::ParseError;

2+use std::env;

4+/// If we use a pager, this enum tells us from where we were told to use it.

5+#[derive(Debug, PartialEq)]

6+pub(crate) enum PagerSource {

7+ /// From --config

8+ Config,

10+ /// From the env var BAT_PAGER

11+ EnvVarBatPager,

12+

13+ /// From the env var PAGER

14+ EnvVarPager,

15+

16+ /// No pager was specified, default is used

17+ Default,

18+}

19+

20+/// We know about some pagers, for example 'less'. This is a list of all pagers we know about

21+#[derive(Debug, PartialEq)]

22+pub(crate) enum PagerKind {

23+ /// bat

24+ Bat,

25+

26+ /// less

27+ Less,

28+

29+ /// more

30+ More,

31+

32+ /// most

33+ Most,

34+

35+ /// A pager we don't know about

36+ Unknown,

37+}

38+

39+impl PagerKind {

40+ fn from_bin(bin: &str) -> PagerKind {

41+ use std::path::Path;

42+

43+ match Path::new(bin)

44+ .file_stem()

45+ .map(|s| s.to_string_lossy())

46+ .as_deref()

47+ {

48+ Some("bat") => PagerKind::Bat,

49+ Some("less") => PagerKind::Less,

50+ Some("more") => PagerKind::More,

51+ Some("most") => PagerKind::Most,

52+ _ => PagerKind::Unknown,

53+ }

54+ }

55+}

56+

57+/// A pager such as 'less', and from where we got it.

58+#[derive(Debug)]

59+pub(crate) struct Pager {

60+ /// The pager binary

61+ pub bin: String,

62+

63+ /// The pager binary arguments (that we might tweak)

64+ pub args: Vec<String>,

65+

66+ /// What pager this is

67+ pub kind: PagerKind,

68+

69+ /// From where this pager comes

70+ pub source: PagerSource,

71+}

72+

73+impl Pager {

74+ fn new(bin: &str, args: &[String], kind: PagerKind, source: PagerSource) -> Pager {

75+ Pager {

76+ bin: String::from(bin),

77+ args: args.to_vec(),

78+ kind,

79+ source,

80+ }

81+ }

82+}

83+

84+/// Returns what pager to use, after looking at both config and environment variables.

85+pub(crate) fn get_pager(config_pager: Option<&str>) -> Result<Option<Pager>, ParseError> {

86+ let bat_pager = env::var("BAT_PAGER");

87+ let pager = env::var("PAGER");

88+

89+ let (cmd, source) = match (config_pager, &bat_pager, &pager) {

90+ (Some(config_pager), _, _) => (config_pager, PagerSource::Config),

91+ (_, Ok(bat_pager), _) => (bat_pager.as_str(), PagerSource::EnvVarBatPager),

92+ (_, _, Ok(pager)) => (pager.as_str(), PagerSource::EnvVarPager),

93+ _ => ("less", PagerSource::Default),

94+ };

95+

96+ let parts = shell_words::split(cmd)?;

97+ match parts.split_first() {

98+ Some((bin, args)) => {

99+ let kind = PagerKind::from_bin(bin);

100+

101+ let use_less_instead = if source == PagerSource::EnvVarPager {

102+ // 'more' and 'most' do not supports colors; automatically use

103+ // 'less' instead if the problematic pager came from the

104+ // generic PAGER env var.

105+ // If PAGER=bat, silently use 'less' instead to prevent

106+ // recursion.

107+ // Never silently use 'less' if BAT_PAGER or --pager has been

108+ // specified.

109+ matches!(kind, PagerKind::More | PagerKind::Most | PagerKind::Bat)

110+ } else {

111+ false

112+ };

113+

114+ Ok(Some(if use_less_instead {

115+ let no_args = vec![];

116+ Pager::new("less", &no_args, PagerKind::Less, PagerSource::EnvVarPager)

117+ } else {

118+ Pager::new(bin, args, kind, source)

119+ }))

120+ }

121+ None => Ok(None),

122+ }

123+}

src/preprocessor.rs+10−3

@@ -53,26 +53,33 @@ pub fn replace_nonprintable(input: &[u8], tab_width: usize) -> String {

5353 let tab_width = if tab_width == 0 { 4 } else { tab_width };

5454

5555 let mut idx = 0;

56+ let mut line_idx = 0;

5657 let len = input.len();

5758 while idx < len {

5859 if let Some((chr, skip_ahead)) = try_parse_utf8_char(&input[idx..]) {

5960 idx += skip_ahead;

61+ line_idx += 1;

6062

6163 match chr {

6264 // space

6365 ' ' => output.push('·'),

6466 // tab

6567 '\t' => {

66− if tab_width == 1 {

68+ let tab_stop = tab_width - ((line_idx - 1) % tab_width);

69+ line_idx = 0;

70+ if tab_stop == 1 {

6771 output.push('↹');

6872 } else {

6973 output.push('├');

70− output.push_str(&"─".repeat(tab_width - 2));

74+ output.push_str(&"─".repeat(tab_stop - 2));

7175 output.push('┤');

7276 }

7377 }

7478 // line feed

75− '\x0A' => output.push('␊'),

79+ '\x0A' => {

80+ output.push_str("␊\x0A");

81+ line_idx = 0;

82+ }

7683 // carriage return

7784 '\x0D' => output.push('␍'),

7885 // null

src/pretty_printer.rs+36−62

@@ -1,5 +1,5 @@

1−use std::ffi::OsStr;

21use std::io::Read;

2+use std::path::Path;

44use console::Term;

55use syntect::parsing::SyntaxReference;

@@ -40,10 +40,11 @@ pub struct PrettyPrinter<'a> {

4040

4141impl<'a> PrettyPrinter<'a> {

4242 pub fn new() -> Self {

43− let mut config = Config::default();

44−

45− config.colored_output = true;

46− config.true_color = true;

43+ let config = Config {

44+ colored_output: true,

45+ true_color: true,

46+ ..Default::default()

47+ };

4748

4849 PrettyPrinter {

4950 inputs: vec![],

@@ -71,7 +72,7 @@ impl<'a> PrettyPrinter<'a> {

7172 }

7273

7374 /// Add a file which should be pretty-printed

74− pub fn input_file(&mut self, path: impl AsRef<OsStr>) -> &mut Self {

75+ pub fn input_file(&mut self, path: impl AsRef<Path>) -> &mut Self {

7576 self.input(Input::from_file(path).kind("File"))

7677 }

7778

@@ -79,7 +80,7 @@ impl<'a> PrettyPrinter<'a> {

7980 pub fn input_files<I, P>(&mut self, paths: I) -> &mut Self

8081 where

8182 I: IntoIterator<Item = P>,

82− P: AsRef<OsStr>,

83+ P: AsRef<Path>,

8384 {

8485 self.inputs(paths.into_iter().map(Input::from_file))

8586 }

@@ -90,48 +91,17 @@ impl<'a> PrettyPrinter<'a> {

9091 self

9192 }

9293

93− /// Add STDIN as an input (with customized name)

94− #[deprecated]

95− pub fn input_stdin_with_name(&mut self, name: impl AsRef<OsStr>) -> &mut Self {

96− self.inputs

97− .push(Input::from_stdin().name(name).kind("File"));

98− self

99− }

100−

10194 /// Add a byte string as an input

10295 pub fn input_from_bytes(&mut self, content: &'a [u8]) -> &mut Self {

10396 self.input_from_reader(content)

10497 }

10598

106− /// Add a byte string as an input (with customized name)

107− #[deprecated]

108− #[allow(deprecated)]

109− pub fn input_from_bytes_with_name(

110− &mut self,

111− content: &'a [u8],

112− name: impl AsRef<OsStr>,

113− ) -> &mut Self {

114− self.input_from_reader_with_name(content, name)

115− }

116−

11799 /// Add a custom reader as an input

118100 pub fn input_from_reader<R: Read + 'a>(&mut self, reader: R) -> &mut Self {

119101 self.inputs.push(Input::from_reader(reader));

120102 self

121103 }

122104

123− /// Add a custom reader as an input (with customized name)

124− #[deprecated]

125− pub fn input_from_reader_with_name<R: Read + 'a>(

126− &mut self,

127− reader: R,

128− name: impl AsRef<OsStr>,

129− ) -> &mut Self {

130− self.inputs

131− .push(Input::from_reader(reader).name(name).kind("File"));

132− self

133− }

134−

135105 /// Specify the syntax file which should be used (default: auto-detect)

136106 pub fn language(&mut self, language: &'a str) -> &mut Self {

137107 self.config.language = Some(language);

@@ -188,19 +158,15 @@ impl<'a> PrettyPrinter<'a> {

188158

189159 /// Whether to show modification markers for VCS changes. This has no effect if

190160 /// the `git` feature is not activated.

191− #[cfg_attr(

192− not(feature = "git"),

193− deprecated(

194− note = "Using vcs_modification_markers without the 'git' feature has no effect. \

195− The function will be removed (for non-'git' use cases) in the future."

196− )

197− )]

198− #[allow(unused_variables)]

161+ #[cfg(feature = "git")]

199162 pub fn vcs_modification_markers(&mut self, yes: bool) -> &mut Self {

200− #[cfg(feature = "git")]

201− {

202− self.active_style_components.vcs_modification_markers = yes;

203− }

163+ self.active_style_components.vcs_modification_markers = yes;

164+ self

165+ }

166+

167+ /// Whether to print binary content or nonprintable characters (default: no)

168+ pub fn show_nonprintable(&mut self, yes: bool) -> &mut Self {

169+ self.config.show_nonprintable = yes;

204170 self

205171 }

206172

@@ -275,7 +241,9 @@ impl<'a> PrettyPrinter<'a> {

275241 }

276242

277243 pub fn syntaxes(&self) -> impl Iterator<Item = &SyntaxReference> {

278− self.assets.syntaxes().iter()

244+ // We always use assets from the binary, which are guaranteed to always

245+ // be valid, so get_syntaxes() can never fail here

246+ self.assets.get_syntaxes().unwrap().iter()

279247 }

280248

281249 /// Pretty-print all specified inputs. This method will "use" all stored inputs.

@@ -320,6 +288,12 @@ impl<'a> PrettyPrinter<'a> {

320288 }

321289}

322290

291+impl Default for PrettyPrinter<'_> {

292+ fn default() -> Self {

293+ Self::new()

294+ }

295+}

296+

323297/// An input source for the pretty printer.

324298pub struct Input<'a> {

325299 input: input::Input<'a>,

@@ -332,8 +306,8 @@ impl<'a> Input<'a> {

332306 }

333307

334308 /// A new input from a file.

335− pub fn from_file(path: impl AsRef<OsStr>) -> Self {

336− input::Input::ordinary_file(path.as_ref()).into()

309+ pub fn from_file(path: impl AsRef<Path>) -> Self {

310+ input::Input::ordinary_file(path).into()

337311 }

338312

339313 /// A new input from bytes.

@@ -348,8 +322,8 @@ impl<'a> Input<'a> {

348322

349323 /// The filename of the input.

350324 /// This affects syntax detection and changes the default header title.

351− pub fn name(mut self, name: impl AsRef<OsStr>) -> Self {

352− self.input = self.input.with_name(Some(name.as_ref()));

325+ pub fn name(mut self, name: impl AsRef<Path>) -> Self {

326+ self.input = self.input.with_name(Some(name));

353327 self

354328 }

355329

@@ -362,7 +336,7 @@ impl<'a> Input<'a> {

362336 self

363337 }

364338

365− /// The title for the input (e.g. "http://example.com/example.txt")

339+ /// The title for the input (e.g. "Descriptive title")

366340 /// This defaults to the file name.

367341 pub fn title(mut self, title: impl Into<String>) -> Self {

368342 self.input.description_mut().set_title(Some(title.into()));

@@ -370,14 +344,14 @@ impl<'a> Input<'a> {

370344 }

371345}

372346

373−impl<'a> Into<Input<'a>> for input::Input<'a> {

374− fn into(self) -> Input<'a> {

375− Input { input: self }

347+impl<'a> From<input::Input<'a>> for Input<'a> {

348+ fn from(input: input::Input<'a>) -> Self {

349+ Self { input }

376350 }

377351}

378352

379−impl<'a> Into<input::Input<'a>> for Input<'a> {

380− fn into(self) -> input::Input<'a> {

381− self.input

353+impl<'a> From<Input<'a>> for input::Input<'a> {

354+ fn from(Input { input }: Input<'a>) -> Self {

355+ input

382356 }

383357}

src/printer.rs+222−149

@@ -4,6 +4,8 @@ use std::vec::Vec;

44use ansi_term::Colour::{Fixed, Green, Red, Yellow};

55use ansi_term::Style;

7+use bytesize::ByteSize;

79use console::AnsiCodeIterator;

810

911use syntect::easy::HighlightLines;

@@ -18,7 +20,7 @@ use encoding::{DecoderTrap, Encoding};

1820

1921use unicode_width::UnicodeWidthChar;

2022

21−use crate::assets::HighlightingAssets;

23+use crate::assets::{HighlightingAssets, SyntaxReferenceInSet};

2224use crate::config::Config;

2325#[cfg(feature = "git")]

2426use crate::decorations::LineChangesDecoration;

@@ -29,7 +31,9 @@ use crate::error::*;

2931use crate::input::OpenedInput;

3032use crate::line_range::RangeCheckResult;

3133use crate::preprocessor::{expand_tabs, replace_nonprintable};

34+use crate::style::StyleComponent;

3235use crate::terminal::{as_terminal_escaped, to_ansi_color};

36+use crate::vscreen::AnsiStyle;

3337use crate::wrapping::WrappingMode;

3438

3539pub(crate) trait Printer {

@@ -91,9 +95,6 @@ impl<'a> Printer for SimplePrinter<'a> {

9195 if self.config.show_nonprintable {

9296 let line = replace_nonprintable(line_buffer, self.config.tab_width);

9397 write!(handle, "{}", line)?;

94− if line_buffer.last() == Some(&b'\n') {

95− writeln!(handle)?;

96− }

9798 } else {

9899 handle.write_all(line_buffer)?

99100 };

@@ -102,17 +103,30 @@ impl<'a> Printer for SimplePrinter<'a> {

102103 }

103104}

104105

106+struct HighlighterFromSet<'a> {

107+ highlighter: HighlightLines<'a>,

108+ syntax_set: &'a SyntaxSet,

109+}

110+

111+impl<'a> HighlighterFromSet<'a> {

112+ fn new(syntax_in_set: SyntaxReferenceInSet<'a>, theme: &'a Theme) -> Self {

113+ Self {

114+ highlighter: HighlightLines::new(syntax_in_set.syntax, theme),

115+ syntax_set: syntax_in_set.syntax_set,

116+ }

117+ }

118+}

119+

105120pub(crate) struct InteractivePrinter<'a> {

106121 colors: Colors,

107122 config: &'a Config<'a>,

108123 decorations: Vec<Box<dyn Decoration>>,

109124 panel_width: usize,

110− ansi_prefix_sgr: String,

125+ ansi_style: AnsiStyle,

111126 content_type: Option<ContentType>,

112127 #[cfg(feature = "git")]

113128 pub line_changes: &'a Option<LineChanges>,

114− highlighter: Option<HighlightLines<'a>>,

115− syntax_set: &'a SyntaxSet,

129+ highlighter_from_set: Option<HighlighterFromSet<'a>>,

116130 background_color_highlight: Option<Color>,

117131}

118132

@@ -166,7 +180,7 @@ impl<'a> InteractivePrinter<'a> {

166180 panel_width = 0;

167181 }

168182

169− let highlighter = if input

183+ let highlighter_from_set = if input

170184 .reader

171185 .content_type

172186 .map_or(false, |c| c.is_binary() && !config.show_nonprintable)

@@ -174,15 +188,16 @@ impl<'a> InteractivePrinter<'a> {

174188 None

175189 } else {

176190 // Determine the type of syntax for highlighting

177− let syntax = match assets.get_syntax(config.language, input, &config.syntax_mapping) {

178− Ok(syntax) => syntax,

179− Err(Error(ErrorKind::UndetectedSyntax(_), _)) => {

180− assets.syntax_set.find_syntax_plain_text()

181− }

182− Err(e) => return Err(e),

183− };

184−

185− Some(HighlightLines::new(syntax, theme))

191+ let syntax_in_set =

192+ match assets.get_syntax(config.language, input, &config.syntax_mapping) {

193+ Ok(syntax_in_set) => syntax_in_set,

194+ Err(Error::UndetectedSyntax(_)) => assets

195+ .find_syntax_by_name("Plain Text")?

196+ .expect("A plain text syntax is available"),

197+ Err(e) => return Err(e),

198+ };

199+

200+ Some(HighlighterFromSet::new(syntax_in_set, theme))

186201 };

187202

188203 Ok(InteractivePrinter {

@@ -191,11 +206,10 @@ impl<'a> InteractivePrinter<'a> {

191206 config,

192207 decorations,

193208 content_type: input.reader.content_type,

194− ansi_prefix_sgr: String::new(),

209+ ansi_style: AnsiStyle::new(),

195210 #[cfg(feature = "git")]

196211 line_changes,

197− highlighter,

198− syntax_set: &assets.syntax_set,

212+ highlighter_from_set,

199213 background_color_highlight,

200214 })

201215 }

@@ -223,29 +237,44 @@ impl<'a> InteractivePrinter<'a> {

223237

224238 fn create_fake_panel(&self, text: &str) -> String {

225239 if self.panel_width == 0 {

226− "".to_string()

240+ return "".to_string();

241+ }

242+

243+ let text_truncated: String = text.chars().take(self.panel_width - 1).collect();

244+ let text_filled: String = format!(

245+ "{}{}",

246+ text_truncated,

247+ " ".repeat(self.panel_width - 1 - text_truncated.len())

248+ );

249+ if self.config.style_components.grid() {

250+ format!("{} │ ", text_filled)

227251 } else {

228− let text_truncated: String = text.chars().take(self.panel_width - 1).collect();

229− let text_filled: String = format!(

252+ text_filled

253+ }

254+ }

255+

256+ fn print_header_component_indent(&mut self, handle: &mut dyn Write) -> std::io::Result<()> {

257+ if self.config.style_components.grid() {

258+ write!(

259+ handle,

230260 "{}{}",

231− text_truncated,

232− " ".repeat(self.panel_width - 1 - text_truncated.len())

233− );

234− if self.config.style_components.grid() {

235− format!("{} │ ", text_filled)

236− } else {

237− text_filled

238− }

261+ " ".repeat(self.panel_width),

262+ self.colors

263+ .grid

264+ .paint(if self.panel_width > 0 { "│ " } else { "" }),

265+ )

266+ } else {

267+ write!(handle, "{}", " ".repeat(self.panel_width))

239268 }

240269 }

241270

242271 fn preprocess(&self, text: &str, cursor: &mut usize) -> String {

243272 if self.config.tab_width > 0 {

244− expand_tabs(text, self.config.tab_width, cursor)

245− } else {

246− *cursor += text.len();

247− text.to_string()

273+ return expand_tabs(text, self.config.tab_width, cursor);

248274 }

275+

276+ *cursor += text.len();

277+ text.to_string()

249278 }

250279}

251280

@@ -276,25 +305,6 @@ impl<'a> Printer for InteractivePrinter<'a> {

276305 return Ok(());

277306 }

278307

279− if self.config.style_components.grid() {

280− self.print_horizontal_line(handle, '┬')?;

281−

282− write!(

283− handle,

284− "{}{}",

285− " ".repeat(self.panel_width),

286− self.colors

287− .grid

288− .paint(if self.panel_width > 0 { "│ " } else { "" }),

289− )?;

290− } else {

291− // Only pad space between files, if we haven't already drawn a horizontal rule

292− if add_header_padding && !self.config.style_components.rule() {

293− writeln!(handle)?;

294− }

295− write!(handle, "{}", " ".repeat(self.panel_width))?;

296− }

297−

298308 let mode = match self.content_type {

299309 Some(ContentType::BINARY) => " <BINARY>",

300310 Some(ContentType::UTF_16LE) => " <UTF-16LE>",

@@ -304,17 +314,60 @@ impl<'a> Printer for InteractivePrinter<'a> {

304314 };

305315

306316 let description = &input.description;

317+ let metadata = &input.metadata;

318+

319+ // We use this iterator to have a deterministic order for

320+ // header components. HashSet has arbitrary order, but Vec is ordered.

321+ let header_components: Vec<StyleComponent> = [

322+ (

323+ StyleComponent::HeaderFilename,

324+ self.config.style_components.header_filename(),

325+ ),

326+ (

327+ StyleComponent::HeaderFilesize,

328+ self.config.style_components.header_filesize(),

329+ ),

330+ ]

331+ .iter()

332+ .filter(|(_, is_enabled)| *is_enabled)

333+ .map(|(component, _)| *component)

334+ .collect();

335+

336+ // Print the cornering grid before the first header component

337+ if self.config.style_components.grid() {

338+ self.print_horizontal_line(handle, '┬')?;

339+ } else {

340+ // Only pad space between files, if we haven't already drawn a horizontal rule

341+ if add_header_padding && !self.config.style_components.rule() {

342+ writeln!(handle)?;

343+ }

344+ }

307345

308− writeln!(

309− handle,

310− "{}{}{}",

311− description

312− .kind()

313− .map(|kind| format!("{}: ", kind))

314− .unwrap_or_else(|| "".into()),

315− self.colors.filename.paint(description.title()),

316− mode

317− )?;

346+ header_components.iter().try_for_each(|component| {

347+ self.print_header_component_indent(handle)?;

348+

349+ match component {

350+ StyleComponent::HeaderFilename => writeln!(

351+ handle,

352+ "{}{}{}",

353+ description

354+ .kind()

355+ .map(|kind| format!("{}: ", kind))

356+ .unwrap_or_else(|| "".into()),

357+ self.colors.header_value.paint(description.title()),

358+ mode

359+ ),

360+

361+ StyleComponent::HeaderFilesize => {

362+ let bsize = metadata

363+ .size

364+ .map(|s| format!("{}", ByteSize(s)))

365+ .unwrap_or_else(|| "-".into());

366+ writeln!(handle, "Size: {}", self.colors.header_value.paint(bsize))

367+ }

368+ _ => Ok(()),

369+ }

370+ })?;

318371

319372 if self.config.style_components.grid() {

320373 if self.content_type.map_or(false, |c| c.is_text()) || self.config.show_nonprintable {

@@ -369,30 +422,44 @@ impl<'a> Printer for InteractivePrinter<'a> {

369422 line_buffer: &[u8],

370423 ) -> Result<()> {

371424 let line = if self.config.show_nonprintable {

372− replace_nonprintable(&line_buffer, self.config.tab_width)

425+ replace_nonprintable(line_buffer, self.config.tab_width)

373426 } else {

374427 match self.content_type {

375428 Some(ContentType::BINARY) | None => {

376429 return Ok(());

377430 }

378431 Some(ContentType::UTF_16LE) => UTF_16LE

379− .decode(&line_buffer, DecoderTrap::Replace)

432+ .decode(line_buffer, DecoderTrap::Replace)

380433 .map_err(|_| "Invalid UTF-16LE")?,

381434 Some(ContentType::UTF_16BE) => UTF_16BE

382− .decode(&line_buffer, DecoderTrap::Replace)

435+ .decode(line_buffer, DecoderTrap::Replace)

383436 .map_err(|_| "Invalid UTF-16BE")?,

384− _ => String::from_utf8_lossy(&line_buffer).to_string(),

437+ _ => String::from_utf8_lossy(line_buffer).to_string(),

385438 }

386439 };

387440

388441 let regions = {

389− let highlighter = match self.highlighter {

390− Some(ref mut highlighter) => highlighter,

442+ let highlighter_from_set = match self.highlighter_from_set {

443+ Some(ref mut highlighter_from_set) => highlighter_from_set,

391444 _ => {

392445 return Ok(());

393446 }

394447 };

395− highlighter.highlight(line.as_ref(), self.syntax_set)

448+

449+ // skip syntax highlighting on long lines

450+ let too_long = line.len() > 1024 * 16;

451+

452+ let for_highlighting: &str = if too_long { "\n" } else { &line };

453+

454+ let mut highlighted_line = highlighter_from_set

455+ .highlighter

456+ .highlight_line(for_highlighting, highlighter_from_set.syntax_set)?;

457+

458+ if too_long {

459+ highlighted_line[0].1 = &line;

460+ }

461+

462+ highlighted_line

396463 };

397464

398465 if out_of_range {

@@ -408,6 +475,10 @@ impl<'a> Printer for InteractivePrinter<'a> {

408475 let highlight_this_line =

409476 self.config.highlighted_lines.0.check(line_number) == RangeCheckResult::InRange;

410477

478+ if highlight_this_line && self.config.theme == "ansi" {

479+ self.ansi_style.update("^[4m");

480+ }

481+

411482 let background_color = self

412483 .background_color_highlight

413484 .filter(|_| highlight_this_line);

@@ -417,8 +488,7 @@ impl<'a> Printer for InteractivePrinter<'a> {

417488 let decorations = self

418489 .decorations

419490 .iter()

420− .map(|ref d| d.generate(line_number, false, self))

421− .collect::<Vec<_>>();

491+ .map(|d| d.generate(line_number, false, self));

422492

423493 for deco in decorations {

424494 write!(handle, "{} ", deco.text)?;

@@ -427,73 +497,72 @@ impl<'a> Printer for InteractivePrinter<'a> {

427497 }

428498

429499 // Line contents.

430− if self.config.wrapping_mode == WrappingMode::NoWrapping {

500+ if matches!(self.config.wrapping_mode, WrappingMode::NoWrapping(_)) {

431501 let true_color = self.config.true_color;

432502 let colored_output = self.config.colored_output;

433503 let italics = self.config.use_italic_text;

434504

435− for &(style, region) in regions.iter() {

436− let text = &*self.preprocess(region, &mut cursor_total);

437− let text_trimmed = text.trim_end_matches(|c| c == '\r' || c == '\n');

438− write!(

439− handle,

440− "{}",

441− as_terminal_escaped(

442− style,

443− text_trimmed,

444− true_color,

445− colored_output,

446− italics,

447− background_color

448− )

449− )?;

505+ for &(style, region) in &regions {

506+ let ansi_iterator = AnsiCodeIterator::new(region);

507+ for chunk in ansi_iterator {

508+ match chunk {

509+ // ANSI escape passthrough.

510+ (ansi, true) => {

511+ self.ansi_style.update(ansi);

512+ write!(handle, "{}", ansi)?;

513+ }

514+

515+ // Regular text.

516+ (text, false) => {

517+ let text = &*self.preprocess(text, &mut cursor_total);

518+ let text_trimmed = text.trim_end_matches(|c| c == '\r' || c == '\n');

450519

451− if text.len() != text_trimmed.len() {

452− if let Some(background_color) = background_color {

453− let mut ansi_style = Style::default();

454− ansi_style.background = Some(to_ansi_color(background_color, true_color));

455− let width = if cursor_total <= cursor_max {

456− cursor_max - cursor_total + 1

457− } else {

458− 0

459− };

460− write!(handle, "{}", ansi_style.paint(" ".repeat(width)))?;

520+ write!(

521+ handle,

522+ "{}",

523+ as_terminal_escaped(

524+ style,

525+ &format!("{}{}", self.ansi_style, text_trimmed),

526+ true_color,

527+ colored_output,

528+ italics,

529+ background_color

530+ )

531+ )?;

532+

533+ if text.len() != text_trimmed.len() {

534+ if let Some(background_color) = background_color {

535+ let ansi_style = Style {

536+ background: to_ansi_color(background_color, true_color),

537+ ..Default::default()

538+ };

539+

540+ let width = if cursor_total <= cursor_max {

541+ cursor_max - cursor_total + 1

542+ } else {

543+ 0

544+ };

545+ write!(handle, "{}", ansi_style.paint(" ".repeat(width)))?;

546+ }

547+ write!(handle, "{}", &text[text_trimmed.len()..])?;

548+ }

549+ }

461550 }

462− write!(handle, "{}", &text[text_trimmed.len()..])?;

463551 }

464552 }

465553

466− if line.bytes().next_back() != Some(b'\n') {

554+ if !self.config.style_components.plain() && line.bytes().next_back() != Some(b'\n') {

467555 writeln!(handle)?;

468556 }

469557 } else {

470− for &(style, region) in regions.iter() {

558+ for &(style, region) in &regions {

471559 let ansi_iterator = AnsiCodeIterator::new(region);

472− let mut ansi_prefix: String = String::new();

473560 for chunk in ansi_iterator {

474561 match chunk {

475562 // ANSI escape passthrough.

476− (text, true) => {

477− let is_ansi_csi = text.starts_with("\x1B[");

478−

479− if is_ansi_csi && text.ends_with('m') {

480− // It's an ANSI SGR sequence.

481− // We should be mostly safe to just append these together.

482− ansi_prefix.push_str(text);

483− if text == "\x1B[0m" {

484− self.ansi_prefix_sgr = "\x1B[0m".to_owned();

485− } else {

486− self.ansi_prefix_sgr.push_str(text);

487− }

488− } else if is_ansi_csi {

489− // It's a regular CSI sequence.

490− // We should be mostly safe to just append these together.

491− ansi_prefix.push_str(text);

492− } else {

493− // It's probably a VT100 code.

494− // Passing it through is the safest bet.

495− write!(handle, "{}", text)?;

496− }

563+ (ansi, true) => {

564+ self.ansi_style.update(ansi);

565+ write!(handle, "{}", ansi)?;

497566 }

498567

499568 // Regular text.

@@ -526,7 +595,7 @@ impl<'a> Printer for InteractivePrinter<'a> {

526595 "{} ",

527596 self.decorations

528597 .iter()

529− .map(|ref d| d

598+ .map(|d| d

530599 .generate(line_number, true, self)

531600 .text)

532601 .collect::<Vec<String>>()

@@ -543,10 +612,7 @@ impl<'a> Printer for InteractivePrinter<'a> {

543612 "{}\n{}",

544613 as_terminal_escaped(

545614 style,

546− &*format!(

547− "{}{}{}",

548− self.ansi_prefix_sgr, ansi_prefix, line_buf

549− ),

615+ &*format!("{}{}", self.ansi_style, line_buf),

550616 self.config.true_color,

551617 self.config.colored_output,

552618 self.config.use_italic_text,

@@ -572,28 +638,23 @@ impl<'a> Printer for InteractivePrinter<'a> {

572638 "{}",

573639 as_terminal_escaped(

574640 style,

575− &*format!(

576− "{}{}{}",

577− self.ansi_prefix_sgr, ansi_prefix, line_buf

578− ),

641+ &*format!("{}{}", self.ansi_style, line_buf),

579642 self.config.true_color,

580643 self.config.colored_output,

581644 self.config.use_italic_text,

582645 background_color

583646 )

584647 )?;

585−

586− // Clear the ANSI prefix buffer.

587− ansi_prefix.clear();

588648 }

589649 }

590650 }

591651 }

592652

593653 if let Some(background_color) = background_color {

594− let mut ansi_style = Style::default();

595− ansi_style.background =

596− Some(to_ansi_color(background_color, self.config.true_color));

654+ let ansi_style = Style {

655+ background: to_ansi_color(background_color, self.config.true_color),

656+ ..Default::default()

657+ };

597658

598659 write!(

599660 handle,

@@ -604,6 +665,11 @@ impl<'a> Printer for InteractivePrinter<'a> {

604665 writeln!(handle)?;

605666 }

606667

668+ if highlight_this_line && self.config.theme == "ansi" {

669+ self.ansi_style.update("^[24m");

670+ write!(handle, "\x1B[24m")?;

671+ }

672+

607673 Ok(())

608674 }

609675}

@@ -614,7 +680,7 @@ const DEFAULT_GUTTER_COLOR: u8 = 238;

614680pub struct Colors {

615681 pub grid: Style,

616682 pub rule: Style,

617− pub filename: Style,

683+ pub header_value: Style,

618684 pub git_added: Style,

619685 pub git_removed: Style,

620686 pub git_modified: Style,

@@ -627,20 +693,27 @@ impl Colors {

627693 }

628694

629695 fn colored(theme: &Theme, true_color: bool) -> Self {

630− let gutter_color = theme

631− .settings

632− .gutter_foreground

633− .map(|c| to_ansi_color(c, true_color))

634− .unwrap_or(Fixed(DEFAULT_GUTTER_COLOR));

696+ let gutter_style = Style {

697+ foreground: match theme.settings.gutter_foreground {

698+ // If the theme provides a gutter foreground color, use it.

699+ // Note: It might be the special value #00000001, in which case

700+ // to_ansi_color returns None and we use an empty Style

701+ // (resulting in the terminal's default foreground color).

702+ Some(c) => to_ansi_color(c, true_color),

703+ // Otherwise, use a specific fallback color.

704+ None => Some(Fixed(DEFAULT_GUTTER_COLOR)),

705+ },

706+ ..Style::default()

707+ };

635708

636709 Colors {

637− grid: gutter_color.normal(),

638− rule: gutter_color.normal(),

639− filename: Style::new().bold(),

710+ grid: gutter_style,

711+ rule: gutter_style,

712+ header_value: Style::new().bold(),

640713 git_added: Green.normal(),

641714 git_removed: Red.normal(),

642715 git_modified: Yellow.normal(),

643− line_number: gutter_color.normal(),

716+ line_number: gutter_style,

644717 }

645718 }

646719}

src/style.rs+30−4

@@ -3,6 +3,7 @@ use std::str::FromStr;

44use crate::error::*;

6+#[non_exhaustive]

67#[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]

78pub enum StyleComponent {

89 Auto,

@@ -11,9 +12,12 @@ pub enum StyleComponent {

1112 Grid,

1213 Rule,

1314 Header,

15+ HeaderFilename,

16+ HeaderFilesize,

1417 LineNumbers,

1518 Snip,

1619 Full,

20+ Default,

1721 Plain,

1822}

1923

@@ -22,7 +26,7 @@ impl StyleComponent {

2226 match self {

2327 StyleComponent::Auto => {

2428 if interactive_terminal {

25− StyleComponent::Full.components(interactive_terminal)

29+ StyleComponent::Default.components(interactive_terminal)

2630 } else {

2731 StyleComponent::Plain.components(interactive_terminal)

2832 }

@@ -31,14 +35,25 @@ impl StyleComponent {

3135 StyleComponent::Changes => &[StyleComponent::Changes],

3236 StyleComponent::Grid => &[StyleComponent::Grid],

3337 StyleComponent::Rule => &[StyleComponent::Rule],

34− StyleComponent::Header => &[StyleComponent::Header],

38+ StyleComponent::Header => &[StyleComponent::HeaderFilename],

39+ StyleComponent::HeaderFilename => &[StyleComponent::HeaderFilename],

40+ StyleComponent::HeaderFilesize => &[StyleComponent::HeaderFilesize],

3541 StyleComponent::LineNumbers => &[StyleComponent::LineNumbers],

3642 StyleComponent::Snip => &[StyleComponent::Snip],

3743 StyleComponent::Full => &[

3844 #[cfg(feature = "git")]

3945 StyleComponent::Changes,

4046 StyleComponent::Grid,

41− StyleComponent::Header,

47+ StyleComponent::HeaderFilename,

48+ StyleComponent::HeaderFilesize,

49+ StyleComponent::LineNumbers,

50+ StyleComponent::Snip,

51+ ],

52+ StyleComponent::Default => &[

53+ #[cfg(feature = "git")]

54+ StyleComponent::Changes,

55+ StyleComponent::Grid,

56+ StyleComponent::HeaderFilename,

4257 StyleComponent::LineNumbers,

4358 StyleComponent::Snip,

4459 ],

@@ -58,9 +73,12 @@ impl FromStr for StyleComponent {

5873 "grid" => Ok(StyleComponent::Grid),

5974 "rule" => Ok(StyleComponent::Rule),

6075 "header" => Ok(StyleComponent::Header),

76+ "header-filename" => Ok(StyleComponent::HeaderFilename),

77+ "header-filesize" => Ok(StyleComponent::HeaderFilesize),

6178 "numbers" => Ok(StyleComponent::LineNumbers),

6279 "snip" => Ok(StyleComponent::Snip),

6380 "full" => Ok(StyleComponent::Full),

81+ "default" => Ok(StyleComponent::Default),

6482 "plain" => Ok(StyleComponent::Plain),

6583 _ => Err(format!("Unknown style '{}'", s).into()),

6684 }

@@ -89,7 +107,15 @@ impl StyleComponents {

89107 }

90108

91109 pub fn header(&self) -> bool {

92− self.0.contains(&StyleComponent::Header)

110+ self.header_filename() || self.header_filesize()

111+ }

112+

113+ pub fn header_filename(&self) -> bool {

114+ self.0.contains(&StyleComponent::HeaderFilename)

115+ }

116+

117+ pub fn header_filesize(&self) -> bool {

118+ self.0.contains(&StyleComponent::HeaderFilesize)

93119 }

94120

95121 pub fn numbers(&self) -> bool {

src/syntax_mapping.rs+53−8

@@ -1,18 +1,36 @@

11use std::path::Path;

33use crate::error::Result;

4+use ignored_suffixes::IgnoredSuffixes;

56use globset::{Candidate, GlobBuilder, GlobMatcher};

8+pub mod ignored_suffixes;

710#[derive(Debug, Clone, Copy, PartialEq)]

11+#[non_exhaustive]

812pub enum MappingTarget<'a> {

13+ /// For mapping a path to a specific syntax.

914 MapTo(&'a str),

15+

16+ /// For mapping a path (typically an extension-less file name) to an unknown

17+ /// syntax. This typically means later using the contents of the first line

18+ /// of the file to determine what syntax to use.

1019 MapToUnknown,

20+

21+ /// For mapping a file extension (e.g. `*.conf`) to an unknown syntax. This

22+ /// typically means later using the contents of the first line of the file

23+ /// to determine what syntax to use. However, if a syntax handles a file

24+ /// name that happens to have the given file extension (e.g. `resolv.conf`),

25+ /// then that association will have higher precedence, and the mapping will

26+ /// be ignored.

27+ MapExtensionToUnknown,

1128}

1229

1330#[derive(Debug, Clone, Default)]

1431pub struct SyntaxMapping<'a> {

1532 mappings: Vec<(GlobMatcher, MappingTarget<'a>)>,

33+ pub(crate) ignored_suffixes: IgnoredSuffixes<'a>,

1634}

1735

1836impl<'a> SyntaxMapping<'a> {

@@ -23,6 +41,9 @@ impl<'a> SyntaxMapping<'a> {

2341 pub fn builtin() -> SyntaxMapping<'a> {

2442 let mut mapping = Self::empty();

2543 mapping.insert("*.h", MappingTarget::MapTo("C++")).unwrap();

44+ mapping

45+ .insert(".clang-format", MappingTarget::MapTo("YAML"))

46+ .unwrap();

2647 mapping.insert("*.fs", MappingTarget::MapTo("F#")).unwrap();

2748 mapping

2849 .insert("build", MappingTarget::MapToUnknown)

@@ -42,6 +63,9 @@ impl<'a> SyntaxMapping<'a> {

4263 MappingTarget::MapTo("Bourne Again Shell (bash)"),

4364 )

4465 .unwrap();

66+ mapping

67+ .insert("*.pac", MappingTarget::MapTo("JavaScript (Babel)"))

68+ .unwrap();

4569

4670 // See #1008

4771 mapping

@@ -51,7 +75,7 @@ impl<'a> SyntaxMapping<'a> {

5175 // Nginx and Apache syntax files both want to style all ".conf" files

5276 // see #1131 and #1137

5377 mapping

54− .insert("*.conf", MappingTarget::MapToUnknown)

78+ .insert("*.conf", MappingTarget::MapExtensionToUnknown)

5579 .unwrap();

5680

5781 for glob in &[

@@ -73,7 +97,7 @@ impl<'a> SyntaxMapping<'a> {

7397 .unwrap();

7498 }

7599

76− for glob in [

100+ for glob in &[

77101 "**/systemd/**/*.conf",

78102 "**/systemd/**/*.example",

79103 "*.automount",

@@ -92,19 +116,36 @@ impl<'a> SyntaxMapping<'a> {

92116 "*.swap",

93117 "*.target",

94118 "*.timer",

95− ]

96− .iter()

97− {

119+ ] {

98120 mapping.insert(glob, MappingTarget::MapTo("INI")).unwrap();

99121 }

100122

123+ // unix mail spool

124+ for glob in &["/var/spool/mail/*", "/var/mail/*"] {

125+ mapping.insert(glob, MappingTarget::MapTo("Email")).unwrap()

126+ }

127+

101128 // pacman hooks

102129 mapping

103130 .insert("*.hook", MappingTarget::MapTo("INI"))

104131 .unwrap();

105132

106− if let Some(xdg_config_home) = std::env::var_os("XDG_CONFIG_HOME") {

107− let git_config_path = Path::new(&xdg_config_home).join("git");

133+ // Global git config files rooted in `$XDG_CONFIG_HOME/git/` or `$HOME/.config/git/`

134+ // See e.g. https://git-scm.com/docs/git-config#FILES

135+ if let Some(xdg_config_home) =

136+ std::env::var_os("XDG_CONFIG_HOME").filter(|val| !val.is_empty())

137+ {

138+ insert_git_config_global(&mut mapping, &xdg_config_home);

139+ }

140+ if let Some(default_config_home) = std::env::var_os("HOME")

141+ .filter(|val| !val.is_empty())

142+ .map(|home| Path::new(&home).join(".config"))

143+ {

144+ insert_git_config_global(&mut mapping, &default_config_home);

145+ }

146+

147+ fn insert_git_config_global(mapping: &mut SyntaxMapping, config_home: impl AsRef<Path>) {

148+ let git_config_path = config_home.as_ref().join("git");

108149

109150 mapping

110151 .insert(

@@ -145,7 +186,7 @@ impl<'a> SyntaxMapping<'a> {

145186 }

146187

147188 pub(crate) fn get_syntax_for(&self, path: impl AsRef<Path>) -> Option<MappingTarget<'a>> {

148− let candidate = Candidate::new(path.as_ref());

189+ let candidate = Candidate::new(&path);

149190 let candidate_filename = path.as_ref().file_name().map(Candidate::new);

150191 for (ref glob, ref syntax) in self.mappings.iter().rev() {

151192 if glob.is_match_candidate(&candidate)

@@ -158,6 +199,10 @@ impl<'a> SyntaxMapping<'a> {

158199 }

159200 None

160201 }

202+

203+ pub fn insert_ignored_suffix(&mut self, suffix: &'a str) {

204+ self.ignored_suffixes.add_suffix(suffix);

205+ }

161206}

162207

163208#[test]

src/syntax_mapping/ignored_suffixes.rsnew file+107

@@ -0,0 +1,107 @@

1+use std::ffi::OsStr;

2+use std::fmt::Debug;

3+use std::path::Path;

5+use crate::error::*;

7+#[derive(Debug, Clone)]

8+pub struct IgnoredSuffixes<'a> {

9+ values: Vec<&'a str>,

10+}

11+

12+impl Default for IgnoredSuffixes<'_> {

13+ fn default() -> Self {

14+ Self {

15+ values: vec![

16+ // Editor etc backups

17+ "~",

18+ ".bak",

19+ ".old",

20+ ".orig",

21+ // Debian and derivatives apt/dpkg/ucf backups

22+ ".dpkg-dist",

23+ ".dpkg-old",

24+ ".ucf-dist",

25+ ".ucf-new",

26+ ".ucf-old",

27+ // Red Hat and derivatives rpm backups

28+ ".rpmnew",

29+ ".rpmorig",

30+ ".rpmsave",

31+ // Build system input/template files

32+ ".in",

33+ ],

34+ }

35+ }

36+}

37+

38+impl<'a> IgnoredSuffixes<'a> {

39+ pub fn add_suffix(&mut self, suffix: &'a str) {

40+ self.values.push(suffix)

41+ }

42+

43+ pub fn strip_suffix(&self, file_name: &'a str) -> Option<&'a str> {

44+ for suffix in self.values.iter() {

45+ if let Some(stripped_file_name) = file_name.strip_suffix(suffix) {

46+ return Some(stripped_file_name);

47+ }

48+ }

49+ None

50+ }

51+

52+ /// If we find an ignored suffix on the file name, e.g. '~', we strip it and

53+ /// then try again without it.

54+ pub fn try_with_stripped_suffix<T, F>(&self, file_name: &'a OsStr, func: F) -> Result<Option<T>>

55+ where

56+ F: Fn(&'a OsStr) -> Result<Option<T>>,

57+ {

58+ if let Some(file_str) = Path::new(file_name).to_str() {

59+ if let Some(stripped_file_name) = self.strip_suffix(file_str) {

60+ return func(OsStr::new(stripped_file_name));

61+ }

62+ }

63+ Ok(None)

64+ }

65+}

66+

67+#[test]

68+fn internal_suffixes() {

69+ let ignored_suffixes = IgnoredSuffixes::default();

70+

71+ let file_names = ignored_suffixes

72+ .values

73+ .iter()

74+ .map(|suffix| format!("test.json{}", suffix));

75+ for file_name_str in file_names {

76+ let file_name = OsStr::new(&file_name_str);

77+ let expected_stripped_file_name = OsStr::new("test.json");

78+ let stripped_file_name = ignored_suffixes

79+ .try_with_stripped_suffix(file_name, |stripped_file_name| Ok(Some(stripped_file_name)));

80+ assert_eq!(

81+ expected_stripped_file_name,

82+ stripped_file_name.unwrap().unwrap()

83+ );

84+ }

85+}

86+

87+#[test]

88+fn external_suffixes() {

89+ let mut ignored_suffixes = IgnoredSuffixes::default();

90+ ignored_suffixes.add_suffix(".development");

91+ ignored_suffixes.add_suffix(".production");

92+

93+ let file_names = ignored_suffixes

94+ .values

95+ .iter()

96+ .map(|suffix| format!("test.json{}", suffix));

97+ for file_name_str in file_names {

98+ let file_name = OsStr::new(&file_name_str);

99+ let expected_stripped_file_name = OsStr::new("test.json");

100+ let stripped_file_name = ignored_suffixes

101+ .try_with_stripped_suffix(file_name, |stripped_file_name| Ok(Some(stripped_file_name)));

102+ assert_eq!(

103+ expected_stripped_file_name,

104+ stripped_file_name.unwrap().unwrap()

105+ );

106+ }

107+}

src/terminal.rs+19−9

@@ -3,13 +3,13 @@ use ansi_term::{self, Style};

44use syntect::highlighting::{self, FontStyle};

6−pub fn to_ansi_color(color: highlighting::Color, true_color: bool) -> ansi_term::Color {

6+pub fn to_ansi_color(color: highlighting::Color, true_color: bool) -> Option<ansi_term::Color> {

77 if color.a == 0 {

88 // Themes can specify one of the user-configurable terminal colors by

99 // encoding them as #RRGGBBAA with AA set to 00 (transparent) and RR set

10− // to the 8-bit color palette number. The built-in themes ansi-light,

11− // ansi-dark, base16, and base16-256 use this.

12− match color.r {

10+ // to the 8-bit color palette number. The built-in themes ansi, base16,

11+ // and base16-256 use this.

12+ Some(match color.r {

1313 // For the first 8 colors, use the Color enum to produce ANSI escape

1414 // sequences using codes 30-37 (foreground) and 40-47 (background).

1515 // For example, red foreground is \x1b[31m. This works on terminals

@@ -31,11 +31,18 @@ pub fn to_ansi_color(color: highlighting::Color, true_color: bool) -> ansi_term:

3131 // 90-97 (foreground) and 100-107 (background), we should use those

3232 // for values 0x08 to 0x0f and only use Fixed for 0x10 to 0xff.

3333 n => Fixed(n),

34− }

34+ })

35+ } else if color.a == 1 {

36+ // Themes can specify the terminal's default foreground/background color

37+ // (i.e. no escape sequence) using the encoding #RRGGBBAA with AA set to

38+ // 01. The built-in theme ansi uses this.

39+ None

3540 } else if true_color {

36− RGB(color.r, color.g, color.b)

41+ Some(RGB(color.r, color.g, color.b))

3742 } else {

38− Fixed(ansi_colours::ansi256_from_rgb((color.r, color.g, color.b)))

43+ Some(Fixed(ansi_colours::ansi256_from_rgb((

44+ color.r, color.g, color.b,

45+ ))))

3946 }

4047}

4148

@@ -54,7 +61,10 @@ pub fn as_terminal_escaped(

5461 let mut style = if !colored {

5562 Style::default()

5663 } else {

57− let mut color = Style::from(to_ansi_color(style.foreground, true_color));

64+ let mut color = Style {

65+ foreground: to_ansi_color(style.foreground, true_color),

66+ ..Style::default()

67+ };

5868 if style.font_style.contains(FontStyle::BOLD) {

5969 color = color.bold();

6070 }

@@ -67,6 +77,6 @@ pub fn as_terminal_escaped(

6777 color

6878 };

6979

70− style.background = background_color.map(|c| to_ansi_color(c, true_color));

80+ style.background = background_color.and_then(|c| to_ansi_color(c, true_color));

7181 style.paint(text).to_string()

7282}

src/vscreen.rsnew file+212

@@ -0,0 +1,212 @@

1+use std::fmt::{Display, Formatter};

3+// Wrapper to avoid unnecessary branching when input doesn't have ANSI escape sequences.

4+pub struct AnsiStyle {

5+ attributes: Option<Attributes>,

6+}

8+impl AnsiStyle {

9+ pub fn new() -> Self {

10+ AnsiStyle { attributes: None }

11+ }

12+

13+ pub fn update(&mut self, sequence: &str) -> bool {

14+ match &mut self.attributes {

15+ Some(a) => a.update(sequence),

16+ None => {

17+ self.attributes = Some(Attributes::new());

18+ self.attributes.as_mut().unwrap().update(sequence)

19+ }

20+ }

21+ }

22+}

23+

24+impl Display for AnsiStyle {

25+ fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {

26+ match self.attributes {

27+ Some(ref a) => a.fmt(f),

28+ None => Ok(()),

29+ }

30+ }

31+}

32+

33+struct Attributes {

34+ foreground: String,

35+ background: String,

36+ underlined: String,

37+

38+ /// The character set to use.

39+ /// REGEX: `\^[()][AB0-3]`

40+ charset: String,

41+

42+ /// A buffer for unknown sequences.

43+ unknown_buffer: String,

44+

45+ /// ON: ^[1m

46+ /// OFF: ^[22m

47+ bold: String,

48+

49+ /// ON: ^[2m

50+ /// OFF: ^[22m

51+ dim: String,

52+

53+ /// ON: ^[4m

54+ /// OFF: ^[24m

55+ underline: String,

56+

57+ /// ON: ^[3m

58+ /// OFF: ^[23m

59+ italic: String,

60+

61+ /// ON: ^[9m

62+ /// OFF: ^[29m

63+ strike: String,

64+}

65+

66+impl Attributes {

67+ pub fn new() -> Self {

68+ Attributes {

69+ foreground: "".to_owned(),

70+ background: "".to_owned(),

71+ underlined: "".to_owned(),

72+ charset: "".to_owned(),

73+ unknown_buffer: "".to_owned(),

74+ bold: "".to_owned(),

75+ dim: "".to_owned(),

76+ underline: "".to_owned(),

77+ italic: "".to_owned(),

78+ strike: "".to_owned(),

79+ }

80+ }

81+

82+ /// Update the attributes with an escape sequence.

83+ /// Returns `false` if the sequence is unsupported.

84+ pub fn update(&mut self, sequence: &str) -> bool {

85+ let mut chars = sequence.char_indices().skip(1);

86+

87+ if let Some((_, t)) = chars.next() {

88+ match t {

89+ '(' => self.update_with_charset('(', chars.map(|(_, c)| c)),

90+ ')' => self.update_with_charset(')', chars.map(|(_, c)| c)),

91+ '[' => {

92+ if let Some((i, last)) = chars.last() {

93+ // SAFETY: Always starts with ^[ and ends with m.

94+ self.update_with_csi(last, &sequence[2..i])

95+ } else {

96+ false

97+ }

98+ }

99+ _ => self.update_with_unsupported(sequence),

100+ }

101+ } else {

102+ false

103+ }

104+ }

105+

106+ fn sgr_reset(&mut self) {

107+ self.foreground.clear();

108+ self.background.clear();

109+ self.underlined.clear();

110+ self.bold.clear();

111+ self.dim.clear();

112+ self.underline.clear();

113+ self.italic.clear();

114+ self.strike.clear();

115+ }

116+

117+ fn update_with_sgr(&mut self, parameters: &str) -> bool {

118+ let mut iter = parameters

119+ .split(';')

120+ .map(|p| if p.is_empty() { "0" } else { p })

121+ .map(|p| p.parse::<u16>())

122+ .map(|p| p.unwrap_or(0)); // Treat errors as 0.

123+

124+ while let Some(p) = iter.next() {

125+ match p {

126+ 0 => self.sgr_reset(),

127+ 1 => self.bold = format!("\x1B[{}m", parameters),

128+ 2 => self.dim = format!("\x1B[{}m", parameters),

129+ 3 => self.italic = format!("\x1B[{}m", parameters),

130+ 4 => self.underline = format!("\x1B[{}m", parameters),

131+ 23 => self.italic.clear(),

132+ 24 => self.underline.clear(),

133+ 22 => {

134+ self.bold.clear();

135+ self.dim.clear();

136+ }

137+ 30..=39 => self.foreground = Self::parse_color(p, &mut iter),

138+ 40..=49 => self.background = Self::parse_color(p, &mut iter),

139+ 58..=59 => self.underlined = Self::parse_color(p, &mut iter),

140+ 90..=97 => self.foreground = Self::parse_color(p, &mut iter),

141+ 100..=107 => self.foreground = Self::parse_color(p, &mut iter),

142+ _ => {

143+ // Unsupported SGR sequence.

144+ // Be compatible and pretend one just wasn't was provided.

145+ }

146+ }

147+ }

148+

149+ true

150+ }

151+

152+ fn update_with_csi(&mut self, finalizer: char, sequence: &str) -> bool {

153+ if finalizer == 'm' {

154+ self.update_with_sgr(sequence)

155+ } else {

156+ false

157+ }

158+ }

159+

160+ fn update_with_unsupported(&mut self, sequence: &str) -> bool {

161+ self.unknown_buffer.push_str(sequence);

162+ false

163+ }

164+

165+ fn update_with_charset(&mut self, kind: char, set: impl Iterator<Item = char>) -> bool {

166+ self.charset = format!("\x1B{}{}", kind, set.take(1).collect::<String>());

167+ true

168+ }

169+

170+ fn parse_color(color: u16, parameters: &mut dyn Iterator<Item = u16>) -> String {

171+ match color % 10 {

172+ 8 => match parameters.next() {

173+ Some(5) /* 256-color */ => format!("\x1B[{};5;{}m", color, join(";", 1, parameters)),

174+ Some(2) /* 24-bit color */ => format!("\x1B[{};2;{}m", color, join(";", 3, parameters)),

175+ Some(c) => format!("\x1B[{};{}m", color, c),

176+ _ => "".to_owned(),

177+ },

178+ 9 => "".to_owned(),

179+ _ => format!("\x1B[{}m", color),

180+ }

181+ }

182+}

183+

184+impl Display for Attributes {

185+ fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {

186+ write!(

187+ f,

188+ "{}{}{}{}{}{}{}{}{}",

189+ self.foreground,

190+ self.background,

191+ self.underlined,

192+ self.charset,

193+ self.bold,

194+ self.dim,

195+ self.underline,

196+ self.italic,

197+ self.strike,

198+ )

199+ }

200+}

201+

202+fn join(

203+ delimiter: &str,

204+ limit: usize,

205+ iterator: &mut dyn Iterator<Item = impl ToString>,

206+) -> String {

207+ iterator

208+ .take(limit)

209+ .map(|i| i.to_string())

210+ .collect::<Vec<String>>()

211+ .join(delimiter)

212+}

src/wrapping.rs+3−2

@@ -1,11 +1,12 @@

11#[derive(Debug, Clone, Copy, PartialEq, Eq)]

22pub enum WrappingMode {

33 Character,

4− NoWrapping,

4+ // The bool specifies whether wrapping has been explicitly disabled by the user via --wrap=never

5+ NoWrapping(bool),

56}

78impl Default for WrappingMode {

89 fn default() -> Self {

9− WrappingMode::NoWrapping

10+ WrappingMode::NoWrapping(false)

1011 }

1112}

tests/.gitattributes+6−6

@@ -4,9 +4,9 @@ snapshots/** text=auto eol=lf

44syntax-tests/source/** text=auto eol=lf

55syntax-tests/highlighted/** text=auto eol=lf

7−examples/* linguist-vendored

8−snapshots/* linguist-vendored

9−benchmarks/* linguist-vendored

10−benchmarks/test-src/* linguist-vendored

11−scripts/* linguist-vendored

12−syntax-tests/* linguist-vendored

7+# Linguist overrides

8+benchmarks/** linguist-vendored

9+examples/** linguist-vendored

10+snapshots/** linguist-vendored

11+syntax-tests/highlighted/** linguist-vendored

12+syntax-tests/source/** linguist-vendored

tests/assets.rs+4−5

@@ -8,7 +8,7 @@ fn all_themes_are_present() {

88 let assets = HighlightingAssets::from_binary();

1010 let mut themes: Vec<_> = assets.themes().collect();

11− themes.sort();

11+ themes.sort_unstable();

1212

1313 assert_eq!(

1414 themes,

@@ -30,13 +30,12 @@ fn all_themes_are_present() {

3030 "Solarized (light)",

3131 "Sublime Snazzy",

3232 "TwoDark",

33− "ansi-dark",

34− "ansi-light",

33+ "Visual Studio Dark+",

34+ "ansi",

3535 "base16",

3636 "base16-256",

37− "gruvbox",

37+ "gruvbox-dark",

3838 "gruvbox-light",

39− "gruvbox-white",

4039 "zenburn"

4140 ]

4241 );

tests/benchmarks/.gitignorenew file+1

@@ -0,0 +1 @@

1+/benchmark-results

tests/benchmarks/comparison.shdeleted−33

@@ -1,33 +0,0 @@

1−#!/usr/bin/env bash

2−

3−cd "$(dirname "${BASH_SOURCE[0]}")"

4−

5−if ! which hyperfine > /dev/null 2>&1; then

6− echo "'hyperfine' does not seem to be installed."

7− echo "You can get it here: https://github.com/sharkdp/hyperfine"

8− exit 1

9−fi

10−

11−SRC="test-src/jquery-3.3.1.js"

12−

13−

14−cmd_bat="bat --style=full --color=always --paging=never '$SRC'"

15−cmd_bat_simple="bat --plain --wrap=never --tabs=0 --color=always --paging=never '$SRC'"

16−cmd_pygmentize="pygmentize -g '$SRC'"

17−cmd_highlight="highlight -O truecolor '$SRC'"

18−cmd_ccat="ccat --color=always '$SRC'"

19−cmd_source_highlight="source-highlight --failsafe --infer-lang -f esc -i '$SRC'"

20−cmd_hicat="hicat '$SRC'"

21−cmd_coderay="coderay '$SRC'"

22−cmd_rouge="rougify '$SRC'"

23−

24−hyperfine --warmup 3 \

25− "$cmd_bat" \

26− "$cmd_bat_simple" \

27− "$cmd_pygmentize" \

28− "$cmd_highlight" \

29− "$cmd_ccat" \

30− "$cmd_source_highlight" \

31− "$cmd_hicat" \

32− "$cmd_coderay" \

33− "$cmd_rouge" \

tests/benchmarks/highlighting-speed-src/grep-output-ansi-sequences.txtnew file+2272

@@ -0,0 +1,2272 @@

1+[35m[K.github/ISSUE_TEMPLATE/syntax_request.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[Kabout: Request adding a new syntax to [1;33m[Kbat[m[K.

2+[35m[K.github/ISSUE_TEMPLATE/syntax_request.md[m[K[36m[K:[m[K[32m[K14[m[K[36m[K:[m[K[1;33m[KBat[m[K supports locally-installed language definitions. See the link below:

3+[35m[K.github/ISSUE_TEMPLATE/syntax_request.md[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[Khttps://github.com/sharkdp/[1;33m[Kbat[m[K#adding-new-syntaxes--language-definitions

4+[35m[K.github/ISSUE_TEMPLATE/question.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[Kabout: Ask a question about '[1;33m[Kbat[m[K'.

5+[35m[K.github/ISSUE_TEMPLATE/bug_report.md[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[K**How did you install `[1;33m[Kbat[m[K`?**

6+[35m[K.github/ISSUE_TEMPLATE/bug_report.md[m[K[36m[K:[m[K[32m[K27[m[K[36m[K:[m[K**[1;33m[Kbat[m[K version and environment**

7+[35m[K.github/ISSUE_TEMPLATE/bug_report.md[m[K[36m[K:[m[K[32m[K31[m[K[36m[K:[m[Kin which you're running [1;33m[Kbat[m[K. To do this, run the full `[1;33m[Kbat[m[K` command that demonstrates

8+[35m[K.github/ISSUE_TEMPLATE/bug_report.md[m[K[36m[K:[m[K[32m[K34[m[K[36m[K:[m[K [1;33m[Kbat[m[K [other options and arguments…] --diagnostic

9+[35m[K.github/ISSUE_TEMPLATE/bug_report.md[m[K[36m[K:[m[K[32m[K40[m[K[36m[K:[m[KIf you are running [1;33m[Kbat[m[K 0.17.1 or older (where --diagnostic is not available), please

10+[35m[K.github/ISSUE_TEMPLATE/bug_report.md[m[K[36m[K:[m[K[32m[K43[m[K[36m[K:[m[K https://github.com/sharkdp/[1;33m[Kbat[m[K/blob/master/diagnostics/info.sh

11+[35m[K.github/ISSUE_TEMPLATE/bug_report.md[m[K[36m[K:[m[K[32m[K46[m[K[36m[K:[m[Kare on Windows, please let us know your [1;33m[Kbat[m[K version and your Windows version.

12+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K69[m[K[36m[K:[m[K - name: Build and install [1;33m[Kbat[m[K

13+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K76[m[K[36m[K:[m[K - name: Build and install [1;33m[Kbat[m[K with updated assets

14+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K94[m[K[36m[K:[m[K run: [1;33m[Kbat[m[K --list-languages

15+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K96[m[K[36m[K:[m[K run: [1;33m[Kbat[m[K --list-themes

16+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K235[m[K[36m[K:[m[K - name: Run [1;33m[Kbat[m[K

17+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K242[m[K[36m[K:[m[K - name: Show diagnostics ([1;33m[Kbat[m[K --diagnostic)

18+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K302[m[K[36m[K:[m[K cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/manual/[1;33m[Kbat[m[K.1 "$ARCHIVE_DIR"

19+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K308[m[K[36m[K:[m[K cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/[1;33m[Kbat[m[K.bash "$ARCHIVE_DIR/autocomplete/${{ env.PROJECT_NAME }}.bash"

20+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K309[m[K[36m[K:[m[K cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/[1;33m[Kbat[m[K.fish "$ARCHIVE_DIR/autocomplete/${{ env.PROJECT_NAME }}.fish"

21+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K310[m[K[36m[K:[m[K cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/_[1;33m[Kbat[m[K.ps1 "$ARCHIVE_DIR/autocomplete/_${{ env.PROJECT_NAME }}.ps1"

22+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K311[m[K[36m[K:[m[K cp 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/[1;33m[Kbat[m[K.zsh "$ARCHIVE_DIR/autocomplete/${{ env.PROJECT_NAME }}.zsh"

23+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K355[m[K[36m[K:[m[K install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/manual/[1;33m[Kbat[m[K.1 "${DPKG_DIR}/usr/share/man/man1/${{ env.PROJECT_NAME }}.1"

24+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K359[m[K[36m[K:[m[K install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/[1;33m[Kbat[m[K.bash "${DPKG_DIR}/usr/share/bash-completion/completions/${{ env.PROJECT_NAME }}"

25+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K360[m[K[36m[K:[m[K install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/[1;33m[Kbat[m[K.fish "${DPKG_DIR}/usr/share/fish/vendor_completions.d/${{ env.PROJECT_NAME }}.fish"

26+[35m[K.github/workflows/CICD.yml[m[K[36m[K:[m[K[32m[K361[m[K[36m[K:[m[K install -Dm644 'target/${{ matrix.job.target }}/release/build/${{ env.PROJECT_NAME }}'-*/out/assets/completions/[1;33m[Kbat[m[K.zsh "${DPKG_DIR}/usr/share/zsh/vendor-completions/_${{ env.PROJECT_NAME }}"

27+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[K <img src="doc/logo-header.svg" alt="[1;33m[Kbat[m[K - a cat clone with wings">

28+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K <a href="https://github.com/sharkdp/[1;33m[Kbat[m[K/actions?query=workflow%3ACICD"><img src="https://github.com/sharkdp/[1;33m[Kbat[m[K/workflows/CICD/badge.svg" alt="Build Status"></a>

29+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K <img src="https://img.shields.io/crates/l/[1;33m[Kbat[m[K.svg" alt="license">

30+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K <a href="https://crates.io/crates/[1;33m[Kbat[m[K"><img src="https://img.shields.io/crates/v/[1;33m[Kbat[m[K.svg?colorB=319e8c" alt="Version info"></a>

31+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[K [<a href="https://github.com/chinanf-boy/[1;33m[Kbat[m[K-zh">中文</a>]

32+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K24[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` supports syntax highlighting for a large number of programming and markup

33+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K31[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` communicates with `git` to show modifications with respect to the index

34+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K45[m[K[36m[K:[m[KBy default, `[1;33m[Kbat[m[K` pipes its own output to a pager (e.g. `less`) if the output is too large for one screen.

35+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K46[m[K[36m[K:[m[KIf you would rather `[1;33m[Kbat[m[K` 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.

36+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K47[m[K[36m[K:[m[KIf you intend to alias `cat` to `[1;33m[Kbat[m[K` in your shell configuration, you can use `alias cat='[1;33m[Kbat[m[K --paging=never'` to preserve the default behavior.

37+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K51[m[K[36m[K:[m[KEven with a pager set, you can still use `[1;33m[Kbat[m[K` to concatenate files :wink:.

38+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K52[m[K[36m[K:[m[KWhenever `[1;33m[Kbat[m[K` detects a non-interactive terminal (i.e. when you pipe into another process or into a file), `[1;33m[Kbat[m[K` will act as a drop-in replacement for `cat` and fall back to printing the plain file contents, regardless of the `--pager` option's value.

39+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K59[m[K[36m[K:[m[K> [1;33m[Kbat[m[K README.md

40+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K65[m[K[36m[K:[m[K> [1;33m[Kbat[m[K src/*.rs

41+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K73[m[K[36m[K:[m[K> curl -s https://sh.rustup.rs | [1;33m[Kbat[m[K

42+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K79[m[K[36m[K:[m[K> yaml2json .travis.yml | json_pp | [1;33m[Kbat[m[K -l json

43+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K84[m[K[36m[K:[m[K> [1;33m[Kbat[m[K -A /etc/hosts

44+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K90[m[K[36m[K:[m[K[1;33m[Kbat[m[K > note.md # quickly create a new file

45+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K92[m[K[36m[K:[m[K[1;33m[Kbat[m[K header.md content.md footer.md > document.md

46+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K94[m[K[36m[K:[m[K[1;33m[Kbat[m[K -n main.rs # show line numbers (only)

47+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K96[m[K[36m[K:[m[K[1;33m[Kbat[m[K f - g # output 'f', then stdin, then 'g'.

48+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K103[m[K[36m[K:[m[KYou can use `[1;33m[Kbat[m[K` as a previewer for [`fzf`](https://github.com/junegunn/fzf). To do this,

49+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K104[m[K[36m[K:[m[Kuse `[1;33m[Kbat[m[K`s `--color=always` option to force colorized output. You can also use `--line-range`

50+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K108[m[K[36m[K:[m[Kfzf --preview '[1;33m[Kbat[m[K --color=always --style=numbers --line-range=:500 {}'

51+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K115[m[K[36m[K:[m[KYou can use the `-exec` option of `find` to preview all search results with `[1;33m[Kbat[m[K`:

52+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K118[m[K[36m[K:[m[Kfind … -exec [1;33m[Kbat[m[K {} +

53+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K121[m[K[36m[K:[m[KIf you happen to use [`fd`](https://github.com/sharkdp/fd), you can use the `-X`/`--exec-[1;33m[Kbat[m[Kch` option to do the same:

54+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K124[m[K[36m[K:[m[Kfd … -X [1;33m[Kbat[m[K

55+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K129[m[K[36m[K:[m[KWith [`[1;33m[Kbat[m[Kgrep`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras/blob/master/doc/[1;33m[Kbat[m[Kgrep.md), `[1;33m[Kbat[m[K` can be used as the printer for [`ripgrep`](https://github.com/BurntSushi/ripgrep) search results.

56+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K132[m[K[36m[K:[m[K[1;33m[Kbat[m[Kgrep needle src/

57+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K137[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` can be combined with `tail -f` to continuously monitor a given file with syntax highlighting.

58+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K140[m[K[36m[K:[m[Ktail -f /var/log/pacman.log | [1;33m[Kbat[m[K --paging=never -l log

59+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K148[m[K[36m[K:[m[KYou can combine `[1;33m[Kbat[m[K` with `git show` to view an older version of a given file with proper syntax

60+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K152[m[K[36m[K:[m[Kgit show v0.6.0:src/main.rs | [1;33m[Kbat[m[K -l rs

61+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K157[m[K[36m[K:[m[KYou can combine `[1;33m[Kbat[m[K` with `git diff` to view lines around code changes with proper syntax

62+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K160[m[K[36m[K:[m[K[1;33m[Kbat[m[Kdiff() {

63+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K161[m[K[36m[K:[m[K git diff --name-only --diff-filter=d | xargs [1;33m[Kbat[m[K --diff

64+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K164[m[K[36m[K:[m[KIf you prefer to use this as a separate tool, check out `[1;33m[Kbat[m[Kdiff` in [`[1;33m[Kbat[m[K-extras`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras).

65+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K170[m[K[36m[K:[m[KThe line numbers and Git modification markers in the output of `[1;33m[Kbat[m[K` can make it hard to copy

66+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K171[m[K[36m[K:[m[Kthe contents of a file. To prevent this, you can call `[1;33m[Kbat[m[K` with the `-p`/`--plain` option or

67+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K174[m[K[36m[K:[m[K[1;33m[Kbat[m[K main.cpp | xclip

68+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K176[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` will detect that the output is being redirected and print the plain file contents.

69+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K180[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` can be used as a colorizing pager for `man`, by setting the

70+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K184[m[K[36m[K:[m[Kexport MANPAGER="sh -c 'col -bx | [1;33m[Kbat[m[K -l man -p'"

71+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K187[m[K[36m[K:[m[K(replace `[1;33m[Kbat[m[K` with `[1;33m[Kbat[m[Kcat` if you are on Debian or Ubuntu)

72+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K192[m[K[36m[K:[m[KIf you prefer to have this bundled in a new command, you can also use [`[1;33m[Kbat[m[Kman`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras/blob/master/doc/[1;33m[Kbat[m[Kman.md).

73+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K196[m[K[36m[K:[m[KAlso, note that this will [not work](https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/1145) with Mandocs `man` implementation.

74+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K200[m[K[36m[K:[m[KThe [`pretty[1;33m[Kbat[m[K`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras/blob/master/doc/pretty[1;33m[Kbat[m[K.md) script is a wrapper that will format code and print it with `[1;33m[Kbat[m[K`.

75+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K205[m[K[36m[K:[m[K[![Packaging status](https://repology.org/badge/vertical-allrepos/[1;33m[Kbat[m[K-cat.svg)](https://repology.org/project/[1;33m[Kbat[m[K-cat/versions)

76+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K210[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` is available on [Ubuntu since 20.04 ("Focal")](https://packages.ubuntu.com/search?keywords=[1;33m[Kbat[m[K&exact=1) and [Debian since August 2021 (Debian 11 - "Bullseye")](https://packages.debian.org/bullseye/[1;33m[Kbat[m[K).

77+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K215[m[K[36m[K:[m[Ksudo apt install [1;33m[Kbat[m[K

78+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K218[m[K[36m[K:[m[K**Important**: If you install `[1;33m[Kbat[m[K` this way, please note that the executable may be installed as `[1;33m[Kbat[m[Kcat` instead of `[1;33m[Kbat[m[K` (due to [a name

79+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K219[m[K[36m[K:[m[Kclash with another package](https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/982)). You can set up a `[1;33m[Kbat[m[K -> [1;33m[Kbat[m[Kcat` symlink or alias to prevent any issues that may come up because of this and to be consistent with other distributions:

80+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K222[m[K[36m[K:[m[Kln -s /usr/bin/[1;33m[Kbat[m[Kcat ~/.local/bin/[1;33m[Kbat[m[K

81+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K229[m[K[36m[K:[m[Kthe most recent release of `[1;33m[Kbat[m[K`, download the latest `.deb` package from the

82+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K230[m[K[36m[K:[m[K[release page](https://github.com/sharkdp/[1;33m[Kbat[m[K/releases) and install it via:

83+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K233[m[K[36m[K:[m[Ksudo dpkg -i [1;33m[Kbat[m[K_0.18.3_amd64.deb # adapt version number and architecture

84+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K238[m[K[36m[K:[m[KYou can install [the `[1;33m[Kbat[m[K` package](https://pkgs.alpinelinux.org/packages?name=[1;33m[Kbat[m[K)

85+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K242[m[K[36m[K:[m[Kapk add [1;33m[Kbat[m[K

86+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K247[m[K[36m[K:[m[KYou can install [the `[1;33m[Kbat[m[K` package](https://www.archlinux.org/packages/community/x86_64/[1;33m[Kbat[m[K/)

87+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K251[m[K[36m[K:[m[Kpacman -S [1;33m[Kbat[m[K

88+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K256[m[K[36m[K:[m[KYou can install [the `[1;33m[Kbat[m[K` package](https://koji.fedoraproject.org/koji/packageinfo?packageID=27506) from the official [Fedora Modular](https://docs.fedoraproject.org/en-US/modularity/using-modules/) repository.

89+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K259[m[K[36m[K:[m[Kdnf install [1;33m[Kbat[m[K

90+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K264[m[K[36m[K:[m[KYou can install [the `[1;33m[Kbat[m[K` package](https://github.com/funtoo/dev-kit/tree/1.4-release/sys-apps/[1;33m[Kbat[m[K) from dev-kit.

91+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K267[m[K[36m[K:[m[Kemerge sys-apps/[1;33m[Kbat[m[K

92+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K272[m[K[36m[K:[m[KYou can install [the `[1;33m[Kbat[m[K` package](https://packages.gentoo.org/packages/sys-apps/[1;33m[Kbat[m[K)

93+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K276[m[K[36m[K:[m[Kemerge sys-apps/[1;33m[Kbat[m[K

94+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K281[m[K[36m[K:[m[KYou can install `[1;33m[Kbat[m[K` via xbps-install:

95+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K283[m[K[36m[K:[m[Kxbps-install -S [1;33m[Kbat[m[K

96+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K288[m[K[36m[K:[m[KYou can install `[1;33m[Kbat[m[K` via pkg:

97+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K290[m[K[36m[K:[m[Kpkg install [1;33m[Kbat[m[K

98+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K295[m[K[36m[K:[m[KYou can install a precompiled [`[1;33m[Kbat[m[K` package](https://www.freshports.org/textproc/[1;33m[Kbat[m[K) with pkg:

99+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K298[m[K[36m[K:[m[Kpkg install [1;33m[Kbat[m[K

100+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K304[m[K[36m[K:[m[Kcd /usr/ports/textproc/[1;33m[Kbat[m[K

101+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K310[m[K[36m[K:[m[KYou can install `[1;33m[Kbat[m[K` package using [`pkg_add(1)`](https://man.openbsd.org/pkg_add.1):

102+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K313[m[K[36m[K:[m[Kpkg_add [1;33m[Kbat[m[K

103+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K318[m[K[36m[K:[m[KYou can install `[1;33m[Kbat[m[K` using the [nix package manager](https://nixos.org/nix):

104+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K321[m[K[36m[K:[m[Knix-env -i [1;33m[Kbat[m[K

105+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K326[m[K[36m[K:[m[KYou can install `[1;33m[Kbat[m[K` with zypper:

106+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K329[m[K[36m[K:[m[Kzypper install [1;33m[Kbat[m[K

107+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K335[m[K[36m[K:[m[KExisting packages may be available, but are not officially supported and may contain [issues](https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/1519).

108+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K339[m[K[36m[K:[m[KYou can install `[1;33m[Kbat[m[K` with [Homebrew on MacOS](https://formulae.brew.sh/formula/[1;33m[Kbat[m[K) or [Homebrew on Linux](https://formulae.brew.sh/formula-linux/[1;33m[Kbat[m[K):

109+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K342[m[K[36m[K:[m[Kbrew install [1;33m[Kbat[m[K

110+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K347[m[K[36m[K:[m[KOr install `[1;33m[Kbat[m[K` with [MacPorts](https://ports.macports.org/port/[1;33m[Kbat[m[K/summary):

111+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K350[m[K[36m[K:[m[Kport install [1;33m[Kbat[m[K

112+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K355[m[K[36m[K:[m[KThere are a few options to install `[1;33m[Kbat[m[K` on Windows. Once you have installed `[1;33m[Kbat[m[K`,

113+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K356[m[K[36m[K:[m[Ktake a look at the ["Using `[1;33m[Kbat[m[K` on Windows"](#using-[1;33m[Kbat[m[K-on-windows) section.

114+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K364[m[K[36m[K:[m[KYou can install `[1;33m[Kbat[m[K` via [Chocolatey](https://chocolatey.org/packages/[1;33m[KBat[m[K):

115+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K366[m[K[36m[K:[m[Kchoco install [1;33m[Kbat[m[K

116+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K371[m[K[36m[K:[m[KYou can install `[1;33m[Kbat[m[K` via [scoop](https://scoop.sh/):

117+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K373[m[K[36m[K:[m[Kscoop install [1;33m[Kbat[m[K

118+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K378[m[K[36m[K:[m[KYou can download prebuilt binaries from the [Release page](https://github.com/sharkdp/[1;33m[Kbat[m[K/releases),

119+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K384[m[K[36m[K:[m[KCheck out the [Release page](https://github.com/sharkdp/[1;33m[Kbat[m[K/releases) for

120+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K385[m[K[36m[K:[m[Kprebuilt versions of `[1;33m[Kbat[m[K` for many different architectures. Statically-linked

121+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K390[m[K[36m[K:[m[KIf you want to build `[1;33m[Kbat[m[K` from source, you need Rust 1.46 or

122+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K394[m[K[36m[K:[m[Kcargo install --locked [1;33m[Kbat[m[K

123+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K404[m[K[36m[K:[m[KUse `[1;33m[Kbat[m[K --list-themes` to get a list of all available themes for syntax

124+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K405[m[K[36m[K:[m[Khighlighting. To select the `TwoDark` theme, call `[1;33m[Kbat[m[K` with the

125+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K406[m[K[36m[K:[m[K`--theme=TwoDark` option or set the `[1;33m[KBAT[m[K_THEME` environment variable to

126+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K407[m[K[36m[K:[m[K`TwoDark`. Use `export [1;33m[KBAT[m[K_THEME="TwoDark"` in your shell's startup file to

127+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K408[m[K[36m[K:[m[Kmake the change permanent. Alternatively, use `[1;33m[Kbat[m[K`s

128+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K409[m[K[36m[K:[m[K[configuration file](https://github.com/sharkdp/[1;33m[Kbat[m[K#configuration-file).

129+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K414[m[K[36m[K:[m[K[1;33m[Kbat[m[K --list-themes | fzf --preview="[1;33m[Kbat[m[K --theme={} --color=always /path/to/file"

130+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K417[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` looks good on a dark background by default. However, if your terminal uses a

131+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K420[m[K[36m[K:[m[K['Adding new themes' section below](https://github.com/sharkdp/[1;33m[Kbat[m[K#adding-new-themes).

132+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K424[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` has three themes that always use [8-bit colors](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors),

133+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K444[m[K[36m[K:[m[KYou can use the `--style` option to control the appearance of `[1;33m[Kbat[m[K`s output.

134+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K446[m[K[36m[K:[m[Kand line numbers but no grid and no file header. Set the `[1;33m[KBAT[m[K_STYLE` environment

135+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K447[m[K[36m[K:[m[Kvariable to make these changes permanent or use `[1;33m[Kbat[m[K`s

136+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K448[m[K[36m[K:[m[K[configuration file](https://github.com/sharkdp/[1;33m[Kbat[m[K#configuration-file).

137+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K452[m[K[36m[K:[m[KShould you find that a particular syntax is not available within `[1;33m[Kbat[m[K`, you can follow these

138+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K453[m[K[36m[K:[m[Kinstructions to easily add new syntaxes to your current `[1;33m[Kbat[m[K` installation.

139+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K455[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` uses the excellent [`syntect`](https://github.com/trishume/syntect/)

140+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K466[m[K[36m[K:[m[K mkdir -p "$([1;33m[Kbat[m[K --config-dir)/syntaxes"

141+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K467[m[K[36m[K:[m[K cd "$([1;33m[Kbat[m[K --config-dir)/syntaxes"

142+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K477[m[K[36m[K:[m[K [1;33m[Kbat[m[K cache --build

143+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K480[m[K[36m[K:[m[K3. Finally, use `[1;33m[Kbat[m[K --list-languages` to check if the new languages are available.

144+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K485[m[K[36m[K:[m[K [1;33m[Kbat[m[K cache --clear

145+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K488[m[K[36m[K:[m[K4. If you think that a specific syntax should be included in `[1;33m[Kbat[m[K` by default, please

146+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K490[m[K[36m[K:[m[K instructions [here](doc/assets.md): [Open Syntax Request](https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/new?labels=syntax-request&template=syntax_request.md).

147+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K498[m[K[36m[K:[m[Kmkdir -p "$([1;33m[Kbat[m[K --config-dir)/themes"

148+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K499[m[K[36m[K:[m[Kcd "$([1;33m[Kbat[m[K --config-dir)/themes"

149+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K505[m[K[36m[K:[m[K[1;33m[Kbat[m[K cache --build

150+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K508[m[K[36m[K:[m[KFinally, use `[1;33m[Kbat[m[K --list-themes` to check if the new themes are available.

151+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K516[m[K[36m[K:[m[K(use `[1;33m[Kbat[m[K --list-languages` for an overview).

152+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K518[m[K[36m[K:[m[KNote: You probably want to use this option as an entry in `[1;33m[Kbat[m[K`s configuration file instead

153+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K539[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` uses the pager that is specified in the `PAGER` environment variable. If this variable is not

154+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K541[m[K[36m[K:[m[K`PAGER` variable or set the `[1;33m[KBAT[m[K_PAGER` environment variable to override what is specified in

155+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K544[m[K[36m[K:[m[K**Note**: If `PAGER` is `more` or `most`, `[1;33m[Kbat[m[K` will silently use `less` instead to ensure support for colors.

156+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K547[m[K[36m[K:[m[K`PAGER`/`[1;33m[KBAT[m[K_PAGER` variables:

157+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K550[m[K[36m[K:[m[Kexport [1;33m[KBAT[m[K_PAGER="less -RF"

158+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K553[m[K[36m[K:[m[KInstead of using environment variables, you can also use `[1;33m[Kbat[m[K`s [configuration file](https://github.com/sharkdp/[1;33m[Kbat[m[K#configuration-file) to configure the pager (`--pager` option).

159+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K556[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` will pass the following command line options to the pager: `-R`/`--RAW-CONTROL-CHARS`,

160+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K572[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` expands tabs to 4 spaces by itself, not relying on the pager. To change this, simply add the

161+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K575[m[K[36m[K:[m[K**Note**: Defining tab stops for the pager (via the `--pager` argument by `[1;33m[Kbat[m[K`, or via the `LESS`

162+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K578[m[K[36m[K:[m[Ksidebar. Calling `[1;33m[Kbat[m[K` with `--tabs=0` will override it and let tabs be consumed by the pager.

163+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K582[m[K[36m[K:[m[KIf you make use of the dark mode feature in macOS, you might want to configure `[1;33m[Kbat[m[K` to use a different

164+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K587[m[K[36m[K:[m[Kalias cat="[1;33m[Kbat[m[K --theme=\$(defaults read -globalDomain AppleInterfaceStyle &> /dev/null && echo default || echo GitHub)"

165+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K593[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` can also be customized with a configuration file. The location of the file is dependent

166+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K596[m[K[36m[K:[m[K[1;33m[Kbat[m[K --config-file

167+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K599[m[K[36m[K:[m[KAlternatively, you can use the `[1;33m[KBAT[m[K_CONFIG_PATH` environment variable to point `[1;33m[Kbat[m[K` to a

168+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K602[m[K[36m[K:[m[Kexport [1;33m[KBAT[m[K_CONFIG_PATH="/path/to/[1;33m[Kbat[m[K.conf"

169+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K607[m[K[36m[K:[m[K[1;33m[Kbat[m[K --generate-config-file

170+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K612[m[K[36m[K:[m[KThe configuration file is a simple list of command line arguments. Use `[1;33m[Kbat[m[K --help` to see a full list of possible options and values. In addition, you can add comments by prepending a line with the `#` character.

171+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K629[m[K[36m[K:[m[K## Using `[1;33m[Kbat[m[K` on Windows

172+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K631[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` mostly works out-of-the-box on Windows, but a few features may need extra configuration.

173+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K653[m[K[36m[K:[m[Kor by setting `[1;33m[KBAT[m[K_PAGER` to an empty string.

174+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K657[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` on Windows does not natively support Cygwin's unix-style paths (`/cygdrive/*`). When passed an absolute cygwin path as an argument, `[1;33m[Kbat[m[K` will encounter the following error: `The system cannot find the path specified. (os error 3)`

175+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K662[m[K[36m[K:[m[K[1;33m[Kbat[m[K() {

176+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K671[m[K[36m[K:[m[K command [1;33m[Kbat[m[K "${args[@]}"

177+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K679[m[K[36m[K:[m[KIf an input file contains color codes or other ANSI escape sequences, `[1;33m[Kbat[m[K` will have problems

178+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K682[m[K[36m[K:[m[Kpassing the `--color=never --wrap=never` options to `[1;33m[Kbat[m[K`.

179+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K686[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` handles terminals *with* and *without* truecolor support. However, the colors in most syntax

180+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K694[m[K[36m[K:[m[K`24bit`. Otherwise, `[1;33m[Kbat[m[K` will not be able to determine whether or not 24-bit escape sequences

181+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K699[m[K[36m[K:[m[KPlease try a different theme (see `[1;33m[Kbat[m[K --list-themes` for a list). The `OneHalfDark` and

182+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K704[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` natively supports UTF-8 as well as UTF-16. For every other file encoding, you may need to

183+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K709[m[K[36m[K:[m[Kiconv -f ISO-8859-1 -t UTF-8 my-file.php | [1;33m[Kbat[m[K

184+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K712[m[K[36m[K:[m[Kby `[1;33m[Kbat[m[K`.

185+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K718[m[K[36m[K:[m[Kgit clone --recursive https://github.com/sharkdp/[1;33m[Kbat[m[K

186+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K721[m[K[36m[K:[m[Kcd [1;33m[Kbat[m[K

187+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K730[m[K[36m[K:[m[K# Build a [1;33m[Kbat[m[K binary with modified syntaxes and themes

188+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K735[m[K[36m[K:[m[KIf you want to build an application that uses `[1;33m[Kbat[m[K`s pretty-printing

189+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K736[m[K[36m[K:[m[Kfeatures as a library, check out the [the API documentation](https://docs.rs/[1;33m[Kbat[m[K/).

190+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K738[m[K[36m[K:[m[Kwhen you depend on `[1;33m[Kbat[m[K` as a library.

191+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K753[m[K[36m[K:[m[KPlease contact [David Peter](https://david-peter.de/) via email if you want to report a vulnerability in `[1;33m[Kbat[m[K`.

192+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K757[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` tries to achieve the following goals:

194+[35m[KREADME.md[m[K[36m[K:[m[K[32m[K770[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` is made available under the terms of either the MIT License or the Apache License 2.0, at your option.

195+[35m[K.gitmodules[m[K[36m[K:[m[K[32m[K198[m[K[36m[K:[m[K url = https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K.git

196+[35m[K.gitmodules[m[K[36m[K:[m[K[32m[K202[m[K[36m[K:[m[K branch = [1;33m[Kbat[m[K-source

197+[35m[Kexamples/list_syntaxes_and_themes.rs[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K/// A simple program that prints its own source code using the [1;33m[Kbat[m[K library

198+[35m[Kexamples/list_syntaxes_and_themes.rs[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::PrettyPrinter;

199+[35m[Kexamples/inputs.rs[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::{Input, PrettyPrinter};

200+[35m[Kexamples/yaml.rs[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::{Input, PrettyPrinter};

201+[35m[Kexamples/advanced.rs[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K/// A program that prints its own source code using the [1;33m[Kbat[m[K library

202+[35m[Kexamples/advanced.rs[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::{PagingMode, PrettyPrinter, WrappingMode};

203+[35m[Kexamples/cat.rs[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K/// A very simple colorized `cat` clone, using `[1;33m[Kbat[m[K` as a library.

204+[35m[Kexamples/cat.rs[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[K/// See `src/bin/[1;33m[Kbat[m[K` for the full `[1;33m[Kbat[m[K` application.

205+[35m[Kexamples/cat.rs[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::PrettyPrinter;

206+[35m[Kexamples/simple.rs[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K/// A simple program that prints its own source code using the [1;33m[Kbat[m[K library

207+[35m[Kexamples/simple.rs[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::PrettyPrinter;

208+[35m[K.gitignore[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K/assets/completions/[1;33m[Kbat[m[K.bash

209+[35m[K.gitignore[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K/assets/completions/[1;33m[Kbat[m[K.fish

210+[35m[K.gitignore[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K/assets/completions/[1;33m[Kbat[m[K.zsh

211+[35m[K.gitignore[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[K/assets/manual/[1;33m[Kbat[m[K.1

212+[35m[Ksrc/input.rs[m[K[36m[K:[m[K[32m[K12[m[K[36m[K:[m[K/// This tells [1;33m[Kbat[m[K how to refer to the input.

213+[35m[Ksrc/error.rs[m[K[36m[K:[m[K[32m[K22[m[K[36m[K:[m[K #[error("Use of [1;33m[Kbat[m[K as a pager is disallowed in order to avoid infinite recursion problems")]

214+[35m[Ksrc/error.rs[m[K[36m[K:[m[K[32m[K23[m[K[36m[K:[m[K InvalidPagerValue[1;33m[KBat[m[K,

215+[35m[Ksrc/error.rs[m[K[36m[K:[m[K[32m[K53[m[K[36m[K:[m[K Red.paint("[[1;33m[Kbat[m[K error]"),

216+[35m[Ksrc/error.rs[m[K[36m[K:[m[K[32m[K59[m[K[36m[K:[m[K writeln!(output, "{}: {}", Red.paint("[[1;33m[Kbat[m[K error]"), error).ok();

217+[35m[Ksrc/lib.rs[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K//! `[1;33m[Kbat[m[K` is a library to print syntax highlighted content.

218+[35m[Ksrc/lib.rs[m[K[36m[K:[m[K[32m[K13[m[K[36m[K:[m[K//! use [1;33m[Kbat[m[K::PrettyPrinter;

219+[35m[Ksrc/macros.rs[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[Kmacro_rules! [1;33m[Kbat[m[K_warning {

220+[35m[Ksrc/macros.rs[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K eprintln!("{}: {}", Yellow.paint("[[1;33m[Kbat[m[K warning]"), format!($($arg)*));

221+[35m[Ksrc/syntax_mapping.rs[m[K[36m[K:[m[K[32m[K52[m[K[36m[K:[m[K "**/[1;33m[Kbat[m[K/config",

222+[35m[Ksrc/pager.rs[m[K[36m[K:[m[K[32m[K10[m[K[36m[K:[m[K /// From the env var [1;33m[KBAT[m[K_PAGER

223+[35m[Ksrc/pager.rs[m[K[36m[K:[m[K[32m[K11[m[K[36m[K:[m[K EnvVar[1;33m[KBat[m[KPager,

224+[35m[Ksrc/pager.rs[m[K[36m[K:[m[K[32m[K23[m[K[36m[K:[m[K /// [1;33m[Kbat[m[K

225+[35m[Ksrc/pager.rs[m[K[36m[K:[m[K[32m[K24[m[K[36m[K:[m[K [1;33m[KBat[m[K,

226+[35m[Ksrc/pager.rs[m[K[36m[K:[m[K[32m[K48[m[K[36m[K:[m[K Some("[1;33m[Kbat[m[K") => PagerKind::[1;33m[KBat[m[K,

227+[35m[Ksrc/pager.rs[m[K[36m[K:[m[K[32m[K86[m[K[36m[K:[m[K let [1;33m[Kbat[m[K_pager = env::var("[1;33m[KBAT[m[K_PAGER");

228+[35m[Ksrc/pager.rs[m[K[36m[K:[m[K[32m[K89[m[K[36m[K:[m[K let (cmd, source) = match (config_pager, &[1;33m[Kbat[m[K_pager, &pager) {

229+[35m[Ksrc/pager.rs[m[K[36m[K:[m[K[32m[K91[m[K[36m[K:[m[K (_, Ok([1;33m[Kbat[m[K_pager), _) => ([1;33m[Kbat[m[K_pager.as_str(), PagerSource::EnvVar[1;33m[KBat[m[KPager),

230+[35m[Ksrc/pager.rs[m[K[36m[K:[m[K[32m[K105[m[K[36m[K:[m[K // If PAGER=[1;33m[Kbat[m[K, silently use 'less' instead to prevent

231+[35m[Ksrc/pager.rs[m[K[36m[K:[m[K[32m[K107[m[K[36m[K:[m[K // Never silently use 'less' if [1;33m[KBAT[m[K_PAGER or --pager has been

232+[35m[Ksrc/pager.rs[m[K[36m[K:[m[K[32m[K109[m[K[36m[K:[m[K matches!(kind, PagerKind::More | PagerKind::Most | PagerKind::[1;33m[KBat[m[K)

233+[35m[Ksrc/assets.rs[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[Kuse crate::{[1;33m[Kbat[m[K_warning, SyntaxMapping};

234+[35m[Ksrc/assets.rs[m[K[36m[K:[m[K[32m[K218[m[K[36m[K:[m[K [1;33m[Kbat[m[K_warning!("Theme '{}' is deprecated, using 'ansi' instead.", theme);

235+[35m[Ksrc/assets.rs[m[K[36m[K:[m[K[32m[K222[m[K[36m[K:[m[K [1;33m[Kbat[m[K_warning!("Unknown theme '{}', using default.", theme)

236+[35m[Ksrc/printer.rs[m[K[36m[K:[m[K[32m[K278[m[K[36m[K:[m[K (but will be present if the output of '[1;33m[Kbat[m[K' is piped). You can use '[1;33m[Kbat[m[K -A' \

237+[35m[Ksrc/printer.rs[m[K[36m[K:[m[K[32m[K280[m[K[36m[K:[m[K Yellow.paint("[[1;33m[Kbat[m[K warning]"),

238+[35m[Ksrc/output.rs[m[K[36m[K:[m[K[32m[K62[m[K[36m[K:[m[K if pager.kind == PagerKind::[1;33m[KBat[m[K {

239+[35m[Ksrc/output.rs[m[K[36m[K:[m[K[32m[K63[m[K[36m[K:[m[K return Err(Error::InvalidPagerValue[1;33m[KBat[m[K);

240+[35m[Ksrc/output.rs[m[K[36m[K:[m[K[32m[K78[m[K[36m[K:[m[K // ANSI color sequences printed by [1;33m[Kbat[m[K. If someone has set PAGER="less -F", we

241+[35m[Ksrc/output.rs[m[K[36m[K:[m[K[32m[K81[m[K[36m[K:[m[K // We only do this for PAGER (as it is not specific to '[1;33m[Kbat[m[K'), not for [1;33m[KBAT[m[K_PAGER

242+[35m[Ksrc/output.rs[m[K[36m[K:[m[K[32m[K82[m[K[36m[K:[m[K // or [1;33m[Kbat[m[Ks '--pager' command line option.

243+[35m[Ksrc/bin/bat/input.rs[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::input::Input;

244+[35m[Ksrc/bin/bat/config.rs[m[K[36m[K:[m[K[32m[K10[m[K[36m[K:[m[K env::var("[1;33m[KBAT[m[K_CONFIG_PATH")

245+[35m[Ksrc/bin/bat/config.rs[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[Kpub fn generate_config_file() -> [1;33m[Kbat[m[K::error::Result<()> {

246+[35m[Ksrc/bin/bat/config.rs[m[K[36m[K:[m[K[32m[K46[m[K[36m[K:[m[K let default_config = r#"# This is `[1;33m[Kbat[m[K`s configuration file. Each line either contains a comment or

247+[35m[Ksrc/bin/bat/config.rs[m[K[36m[K:[m[K[32m[K47[m[K[36m[K:[m[K# a command-line option that you want to pass to `[1;33m[Kbat[m[K` by default. You can

248+[35m[Ksrc/bin/bat/config.rs[m[K[36m[K:[m[K[32m[K48[m[K[36m[K:[m[K# run `[1;33m[Kbat[m[K --help` to get a list of all possible configuration options.

249+[35m[Ksrc/bin/bat/config.rs[m[K[36m[K:[m[K[32m[K50[m[K[36m[K:[m[K# Specify desired highlighting theme (e.g. "TwoDark"). Run `[1;33m[Kbat[m[K --list-themes`

250+[35m[Ksrc/bin/bat/config.rs[m[K[36m[K:[m[K[32m[K62[m[K[36m[K:[m[K# enable mouse scrolling support in `[1;33m[Kbat[m[K` when running inside tmux. This might

251+[35m[Ksrc/bin/bat/config.rs[m[K[36m[K:[m[K[32m[K98[m[K[36m[K:[m[K env::var("[1;33m[KBAT[m[K_OPTS").ok().map(|s| get_args_from_str(&s))

252+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K/// The `XDG_CACHE_HOME` environment variable is checked first. `[1;33m[KBAT[m[K_CONFIG_DIR`

253+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K9[m[K[36m[K:[m[K/// The fallback directories are `~/.cache/[1;33m[Kbat[m[K` and `~/.config/[1;33m[Kbat[m[K`, respectively.

254+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K10[m[K[36m[K:[m[Kpub struct [1;33m[KBat[m[KProjectDirs {

255+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K15[m[K[36m[K:[m[Kimpl [1;33m[KBat[m[KProjectDirs {

256+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[K fn new() -> Option<[1;33m[KBat[m[KProjectDirs> {

257+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K17[m[K[36m[K:[m[K let cache_dir = [1;33m[KBat[m[KProjectDirs::get_cache_dir()?;

258+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K19[m[K[36m[K:[m[K // Checks whether or not $[1;33m[KBAT[m[K_CONFIG_DIR exists. If it doesn't, set our config dir

259+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K22[m[K[36m[K:[m[K if let Some(config_dir_op) = env::var_os("[1;33m[KBAT[m[K_CONFIG_DIR").map(PathBuf::from) {

260+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K34[m[K[36m[K:[m[K config_dir_op.map(|d| d.join("[1;33m[Kbat[m[K"))?

261+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K37[m[K[36m[K:[m[K Some([1;33m[KBat[m[KProjectDirs {

262+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K44[m[K[36m[K:[m[K // on all OS prefer [1;33m[KBAT[m[K_CACHE_PATH if set

263+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K45[m[K[36m[K:[m[K let cache_dir_op = env::var_os("[1;33m[KBAT[m[K_CACHE_PATH").map(PathBuf::from);

264+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K59[m[K[36m[K:[m[K cache_dir_op.map(|d| d.join("[1;33m[Kbat[m[K"))

265+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K72[m[K[36m[K:[m[K pub static ref PROJECT_DIRS: [1;33m[KBat[m[KProjectDirs =

266+[35m[Ksrc/bin/bat/directories.rs[m[K[36m[K:[m[K[32m[K73[m[K[36m[K:[m[K [1;33m[KBat[m[KProjectDirs::new().expect("Could not get home directory");

267+[35m[Ksrc/bin/bat/app.rs[m[K[36m[K:[m[K[32m[K17[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::{

268+[35m[Ksrc/bin/bat/app.rs[m[K[36m[K:[m[K[32m[K19[m[K[36m[K:[m[K [1;33m[Kbat[m[K_warning,

269+[35m[Ksrc/bin/bat/app.rs[m[K[36m[K:[m[K[32m[K56[m[K[36m[K:[m[K // Skip the arguments in [1;33m[Kbat[m[Ks config file

270+[35m[Ksrc/bin/bat/app.rs[m[K[36m[K:[m[K[32m[K62[m[K[36m[K:[m[K // Read arguments from [1;33m[Kbat[m[Ks config file

271+[35m[Ksrc/bin/bat/app.rs[m[K[36m[K:[m[K[32m[K191[m[K[36m[K:[m[K .or_else(|| env::var("[1;33m[KBAT[m[K_TABS").ok())

272+[35m[Ksrc/bin/bat/app.rs[m[K[36m[K:[m[K[32m[K204[m[K[36m[K:[m[K .or_else(|| env::var("[1;33m[KBAT[m[K_THEME").ok())

273+[35m[Ksrc/bin/bat/app.rs[m[K[36m[K:[m[K[32m[K305[m[K[36m[K:[m[K let env_style_components: Option<Vec<StyleComponent>> = env::var("[1;33m[KBAT[m[K_STYLE")

274+[35m[Ksrc/bin/bat/app.rs[m[K[36m[K:[m[K[32m[K336[m[K[36m[K:[m[K [1;33m[Kbat[m[K_warning!("Style 'rule' is a subset of style 'grid', 'rule' will not be visible.");

275+[35m[Ksrc/bin/bat/assets.rs[m[K[36m[K:[m[K[32m[K9[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::assets::HighlightingAssets;

276+[35m[Ksrc/bin/bat/assets.rs[m[K[36m[K:[m[K[32m[K10[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::assets_metadata::AssetsMetadata;

277+[35m[Ksrc/bin/bat/assets.rs[m[K[36m[K:[m[K[32m[K11[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::error::*;

278+[35m[Ksrc/bin/bat/assets.rs[m[K[36m[K:[m[K[32m[K34[m[K[36m[K:[m[K in '{}' are not compatible with this version of [1;33m[Kbat[m[K ({}). To solve this, \

279+[35m[Ksrc/bin/bat/assets.rs[m[K[36m[K:[m[K[32m[K35[m[K[36m[K:[m[K either rebuild the cache ([1;33m[Kbat[m[K cache --build) or remove \

280+[35m[Ksrc/bin/bat/assets.rs[m[K[36m[K:[m[K[32m[K36[m[K[36m[K:[m[K the custom syntaxes/themes ([1;33m[Kbat[m[K cache --clear).\n\

281+[35m[Ksrc/bin/bat/assets.rs[m[K[36m[K:[m[K[32m[K38[m[K[36m[K:[m[K https://github.com/sharkdp/[1;33m[Kbat[m[K#adding-new-syntaxes--language-definitions",

282+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K28[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::{

283+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K52[m[K[36m[K:[m[K [1;33m[Kbat[m[K::assets::build(source_dir, !blank, target_dir, clap::crate_version!())

284+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K60[m[K[36m[K:[m[K println!("[1;33m[Kbat[m[K has been built without the 'build-assets' feature. The 'cache --build' option is not available.");

285+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K207[m[K[36m[K:[m[K and are added to the cache with `[1;33m[Kbat[m[K cache --build`. \

286+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K209[m[K[36m[K:[m[K https://github.com/sharkdp/[1;33m[Kbat[m[K#adding-new-themes",

287+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K230[m[K[36m[K:[m[K let pager = [1;33m[Kbat[m[K::config::get_pager_executable(app.matches.value_of("pager"))

288+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K243[m[K[36m[K:[m[K "[1;33m[KBAT[m[K_PAGER",

289+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K244[m[K[36m[K:[m[K "[1;33m[KBAT[m[K_CACHE_PATH",

290+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K245[m[K[36m[K:[m[K "[1;33m[KBAT[m[K_CONFIG_PATH",

291+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K246[m[K[36m[K:[m[K "[1;33m[KBAT[m[K_OPTS",

292+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K247[m[K[36m[K:[m[K "[1;33m[KBAT[m[K_STYLE",

293+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K248[m[K[36m[K:[m[K "[1;33m[KBAT[m[K_TABS",

294+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K249[m[K[36m[K:[m[K "[1;33m[KBAT[m[K_THEME",

295+[35m[Ksrc/bin/bat/main.rs[m[K[36m[K:[m[K[32m[K280[m[K[36m[K:[m[K println!("[1;33m[Kbat[m[K has been built without the 'bugreport' feature. The '--diagnostic' option is not available.");

296+[35m[Ksrc/bin/bat/clap_app.rs[m[K[36m[K:[m[K[32m[K43[m[K[36m[K:[m[K "Note: `[1;33m[Kbat[m[K -h` prints a short and concise overview while `[1;33m[Kbat[m[K --help` gives all \

297+[35m[Ksrc/bin/bat/clap_app.rs[m[K[36m[K:[m[K[32m[K127[m[K[36m[K:[m[K data to [1;33m[Kbat[m[K from STDIN when [1;33m[Kbat[m[K does not otherwise know \

298+[35m[Ksrc/bin/bat/clap_app.rs[m[K[36m[K:[m[K[32m[K290[m[K[36m[K:[m[K if the output of [1;33m[Kbat[m[K is piped to another program, but you want \

299+[35m[Ksrc/bin/bat/clap_app.rs[m[K[36m[K:[m[K[32m[K306[m[K[36m[K:[m[K set [1;33m[KBAT[m[K_PAGER to an empty string. To control which pager is used, see the \

300+[35m[Ksrc/bin/bat/clap_app.rs[m[K[36m[K:[m[K[32m[K330[m[K[36m[K:[m[K PAGER and [1;33m[KBAT[m[K_PAGER environment variables. The default pager is 'less'. \

301+[35m[Ksrc/bin/bat/clap_app.rs[m[K[36m[K:[m[K[32m[K363[m[K[36m[K:[m[K [1;33m[KBAT[m[K_THEME environment variable (e.g.: export \

302+[35m[Ksrc/bin/bat/clap_app.rs[m[K[36m[K:[m[K[32m[K364[m[K[36m[K:[m[K [1;33m[KBAT[m[K_THEME=\"...\").",

303+[35m[Ksrc/bin/bat/clap_app.rs[m[K[36m[K:[m[K[32m[K412[m[K[36m[K:[m[K [1;33m[KBAT[m[K_STYLE environment variable (e.g.: export [1;33m[KBAT[m[K_STYLE=\"..\").\n\n\

304+[35m[Ksrc/bin/bat/clap_app.rs[m[K[36m[K:[m[K[32m[K497[m[K[36m[K:[m[K .help("Show [1;33m[Kbat[m[K's configuration directory."),

305+[35m[Ksrc/bin/bat/clap_app.rs[m[K[36m[K:[m[K[32m[K503[m[K[36m[K:[m[K .help("Show [1;33m[Kbat[m[K's cache directory."),

306+[35m[Ksrc/bin/bat/clap_app.rs[m[K[36m[K:[m[K[32m[K521[m[K[36m[K:[m[K '[1;33m[Kbat[m[K --ignored-suffix \".dev\" my_file.json.dev' will use JSON syntax, and ignore '.dev'"

307+[35m[Ksrc/bin/bat/clap_app.rs[m[K[36m[K:[m[K[32m[K528[m[K[36m[K:[m[K // enable the '[1;33m[Kbat[m[K cache' subcommand.

308+[35m[Ksrc/assets/serialized_syntax_set.rs[m[K[36m[K:[m[K[32m[K14[m[K[36m[K:[m[K /// The data to use is embedded into the [1;33m[Kbat[m[K binary.

309+[35m[Ksrc/assets/build_assets.rs[m[K[36m[K:[m[K[32m[K246[m[K[36m[K:[m[K if std::env::var("[1;33m[KBAT[m[K_PRINT_SYNTAX_DEPENDENCIES").is_ok() {

310+[35m[Ksrc/assets/build_assets.rs[m[K[36m[K:[m[K[32m[K248[m[K[36m[K:[m[K // [1;33m[KBAT[m[K_PRINT_SYNTAX_DEPENDENCIES=1 cargo run -- cache --build --source assets --blank --target /tmp

311+[35m[Ksrc/assets/build_assets.rs[m[K[36m[K:[m[K[32m[K342[m[K[36m[K:[m[K/// [1;33m[KBAT[m[K_SYNTAX_DEPENDENCIES_TO_GRAPHVIZ_DOT_FILE=/tmp/[1;33m[Kbat[m[K-syntax-dependencies.dot cargo run -- cache --build --source assets --blank --target /tmp

312+[35m[Ksrc/assets/build_assets.rs[m[K[36m[K:[m[K[32m[K343[m[K[36m[K:[m[K/// dot /tmp/[1;33m[Kbat[m[K-syntax-dependencies.dot -Tpng -o /tmp/[1;33m[Kbat[m[K-syntax-dependencies.png

313+[35m[Ksrc/assets/build_assets.rs[m[K[36m[K:[m[K[32m[K344[m[K[36m[K:[m[K/// open /tmp/[1;33m[Kbat[m[K-syntax-dependencies.png

314+[35m[Ksrc/assets/build_assets.rs[m[K[36m[K:[m[K[32m[K350[m[K[36m[K:[m[K if let Ok(dot_file_path) = std::env::var("[1;33m[KBAT[m[K_SYNTAX_DEPENDENCIES_TO_GRAPHVIZ_DOT_FILE") {

315+[35m[Ksrc/assets/build_assets.rs[m[K[36m[K:[m[K[32m[K424[m[K[36m[K:[m[K if std::env::var("[1;33m[KBAT[m[K_INCLUDE_SYNTAX_DEPENDENTS").is_ok() {

316+[35m[Ksrc/assets/assets_metadata.rs[m[K[36m[K:[m[K[32m[K12[m[K[36m[K:[m[K [1;33m[Kbat[m[K_version: Option<String>,

317+[35m[Ksrc/assets/assets_metadata.rs[m[K[36m[K:[m[K[32m[K22[m[K[36m[K:[m[K [1;33m[Kbat[m[K_version: Some(current_version.to_owned()),

318+[35m[Ksrc/assets/assets_metadata.rs[m[K[36m[K:[m[K[32m[K48[m[K[36m[K:[m[K /// => assume that these were created by an old version of [1;33m[Kbat[m[K and return

319+[35m[Ksrc/assets/assets_metadata.rs[m[K[36m[K:[m[K[32m[K69[m[K[36m[K:[m[K Version::parse(current_version).expect("[1;33m[Kbat[m[K follows semantic versioning");

320+[35m[Ksrc/assets/assets_metadata.rs[m[K[36m[K:[m[K[32m[K71[m[K[36m[K:[m[K .[1;33m[Kbat[m[K_version

321+[35m[Ksrc/assets/build_assets/graphviz_utils.rs[m[K[36m[K:[m[K[32m[K30[m[K[36m[K:[m[K writeln!(dot_file, "digraph [1;33m[KBat[m[KSyntaxDependencies {{")?;

322+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[K// For more details, see https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/372

323+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K// For [1;33m[Kbat[m[K-as-a-library, no build script is required. The build script is for

324+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K// the manpage and completions, which are only relevant to the [1;33m[Kbat[m[K application.

325+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K17[m[K[36m[K:[m[K let project_name = option_env!("PROJECT_NAME").unwrap_or("[1;33m[Kbat[m[K");

326+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K54[m[K[36m[K:[m[K "assets/manual/[1;33m[Kbat[m[K.1.in",

327+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K55[m[K[36m[K:[m[K out_dir.join("assets/manual/[1;33m[Kbat[m[K.1"),

328+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K59[m[K[36m[K:[m[K "assets/completions/[1;33m[Kbat[m[K.bash.in",

329+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K60[m[K[36m[K:[m[K out_dir.join("assets/completions/[1;33m[Kbat[m[K.bash"),

330+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K64[m[K[36m[K:[m[K "assets/completions/[1;33m[Kbat[m[K.fish.in",

331+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K65[m[K[36m[K:[m[K out_dir.join("assets/completions/[1;33m[Kbat[m[K.fish"),

332+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K69[m[K[36m[K:[m[K "assets/completions/_[1;33m[Kbat[m[K.ps1.in",

333+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K70[m[K[36m[K:[m[K out_dir.join("assets/completions/_[1;33m[Kbat[m[K.ps1"),

334+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K74[m[K[36m[K:[m[K "assets/completions/[1;33m[Kbat[m[K.zsh.in",

335+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K75[m[K[36m[K:[m[K out_dir.join("assets/completions/[1;33m[Kbat[m[K.zsh"),

336+[35m[Kbuild.rs[m[K[36m[K:[m[K[32m[K89[m[K[36m[K:[m[K// const BIN_NAME: &str = "[1;33m[Kbat[m[K";

337+[35m[K.git/info/refs[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[Kb41fb0df6cf831081754c27a4c33227c166eee69 refs/heads/[1;33m[Kbat[m[K-0.16-updates

338+[35m[K.git/info/refs[m[K[36m[K:[m[K[32m[K22[m[K[36m[K:[m[Kb5a40d0866e6a190fbee095ac104fdc6ec168d0a refs/heads/[1;33m[Kbat[m[K-0.18.2-release

339+[35m[K.git/info/refs[m[K[36m[K:[m[K[32m[K23[m[K[36m[K:[m[Kfa0d448cd3e652ffd3c5caa4caa4bdbe2973241c refs/heads/[1;33m[Kbat[m[K-config-file

340+[35m[K.git/info/refs[m[K[36m[K:[m[K[32m[K24[m[K[36m[K:[m[K27516c6f26dc1319dc2516e7caf1aafbe8d30aa0 refs/heads/[1;33m[Kbat[m[K-diagnostic-option

341+[35m[K.git/info/refs[m[K[36m[K:[m[K[32m[K25[m[K[36m[K:[m[Kcd501edcbded4dc344e0a0478472b0a4819c2251 refs/heads/[1;33m[Kbat[m[K-diff

342+[35m[K.git/info/refs[m[K[36m[K:[m[K[32m[K26[m[K[36m[K:[m[Kd77742b2e425cd76e2ca90a75efba4205e280859 refs/heads/[1;33m[Kbat[m[K-diff-fixes

343+[35m[K.git/info/refs[m[K[36m[K:[m[K[32m[K215[m[K[36m[K:[m[Kf1f8807a38052c8138c6f8d1b3bf125e30588712 refs/remotes/origin/[1;33m[Kbat[m[K-v0.18.3-candidate

344+[35m[K.git/FETCH_HEAD[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K619cf6e6d6641dbb913dddd56907a54c6a9f6ce6 branch 'master' of https://github.com/sharkdp/[1;33m[Kbat[m[K

345+[35m[K.git/FETCH_HEAD[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[K8244eb8ef88cc1b64d27991d6a5c7c69586b8a13 not-for-merge branch 'ci-experiment' of https://github.com/sharkdp/[1;33m[Kbat[m[K

346+[35m[K.git/FETCH_HEAD[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K271842d87c816cb80dc0a1c48eefee99c9439db6 not-for-merge branch 'create_highlighted_versions-wrong-path-repro' of https://github.com/sharkdp/[1;33m[Kbat[m[K

347+[35m[K.git/FETCH_HEAD[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[Kc42ec074ea6accdc38b8d9278bc3810343e2d1a3 not-for-merge branch 'dependabot/submodules/assets/syntaxes/02_Extra/PowerShell-742f0b5' of https://github.com/sharkdp/[1;33m[Kbat[m[K

348+[35m[K.git/FETCH_HEAD[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[Kfb9c30b1f7ff648d8aa8fb35a8ff669513c8e91f not-for-merge branch 'dependabot/submodules/assets/syntaxes/02_Extra/SCSS_Sass-d3d9404' of https://github.com/sharkdp/[1;33m[Kbat[m[K

349+[35m[K.git/FETCH_HEAD[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K179d905bb92eee7272cf6fbb38db88f9294df94a not-for-merge branch 'dependabot/submodules/assets/syntaxes/02_Extra/TypeScript-ba45efd' of https://github.com/sharkdp/[1;33m[Kbat[m[K

350+[35m[K.git/FETCH_HEAD[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[Kb146958ecbb8c8c926159509ca7fb32a8573f897 not-for-merge branch 'release-v0.18.3' of https://github.com/sharkdp/[1;33m[Kbat[m[K

351+[35m[K.git/logs/HEAD[m[K[36m[K:[m[K[32m[K14[m[K[36m[K:[m[Ka946f3ae23e7d6d9aa6361c034e9b62859b4dbff e92e13cd4332196617df7a07bc6c55d1fd4834bb David Peter <mail@david-peter.de> 1631038809 +0200 rebase (continue) (pick): Use [1;33m[KBAT[m[K_CONFIG_DIR and [1;33m[KBAT[m[K_CACHE_PATH

352+[35m[K.git/modules/assets/themes/Coldark/FETCH_HEAD[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[Ke44750b2a9629dd12d8ed3ad9fd50c77232170b9 not-for-merge branch 'master' of https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K

353+[35m[K.git/modules/assets/themes/Coldark/logs/refs/heads/master[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K0000000000000000000000000000000000000000 b4a1c74d8d5bdd136ec530e5905b810272472545 sharkdp <davidpeter@web.de> 1603543180 +0200 clone: from https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K.git

354+[35m[K.git/modules/assets/themes/Coldark/logs/refs/remotes/origin/HEAD[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K0000000000000000000000000000000000000000 b4a1c74d8d5bdd136ec530e5905b810272472545 sharkdp <davidpeter@web.de> 1603543180 +0200 clone: from https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K.git

355+[35m[K.git/modules/assets/themes/Coldark/logs/HEAD[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K0000000000000000000000000000000000000000 b4a1c74d8d5bdd136ec530e5905b810272472545 sharkdp <davidpeter@web.de> 1603543180 +0200 clone: from https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K.git

356+[35m[K.git/modules/assets/themes/Coldark/config[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[K url = https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K.git

357+[35m[K.git/modules/assets/themes/gruvbox/FETCH_HEAD[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K64c47250e54298b91e2cf8d401320009aba9f991 not-for-merge branch '[1;33m[Kbat[m[K-source' of https://github.com/subnut/gruvbox-tmTheme

358+[35m[K.git/packed-refs[m[K[36m[K:[m[K[32m[K22[m[K[36m[K:[m[Kb41fb0df6cf831081754c27a4c33227c166eee69 refs/heads/[1;33m[Kbat[m[K-0.16-updates

359+[35m[K.git/packed-refs[m[K[36m[K:[m[K[32m[K23[m[K[36m[K:[m[Kb5a40d0866e6a190fbee095ac104fdc6ec168d0a refs/heads/[1;33m[Kbat[m[K-0.18.2-release

360+[35m[K.git/packed-refs[m[K[36m[K:[m[K[32m[K24[m[K[36m[K:[m[Kfa0d448cd3e652ffd3c5caa4caa4bdbe2973241c refs/heads/[1;33m[Kbat[m[K-config-file

361+[35m[K.git/packed-refs[m[K[36m[K:[m[K[32m[K25[m[K[36m[K:[m[K27516c6f26dc1319dc2516e7caf1aafbe8d30aa0 refs/heads/[1;33m[Kbat[m[K-diagnostic-option

362+[35m[K.git/packed-refs[m[K[36m[K:[m[K[32m[K26[m[K[36m[K:[m[Kcd501edcbded4dc344e0a0478472b0a4819c2251 refs/heads/[1;33m[Kbat[m[K-diff

363+[35m[K.git/packed-refs[m[K[36m[K:[m[K[32m[K27[m[K[36m[K:[m[Kd77742b2e425cd76e2ca90a75efba4205e280859 refs/heads/[1;33m[Kbat[m[K-diff-fixes

364+[35m[K.git/packed-refs[m[K[36m[K:[m[K[32m[K216[m[K[36m[K:[m[Kf1f8807a38052c8138c6f8d1b3bf125e30588712 refs/remotes/origin/[1;33m[Kbat[m[K-v0.18.3-candidate

365+[35m[K.git/config[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K url = https://github.com/sharkdp/[1;33m[Kbat[m[K.git

366+[35m[K.git/config[m[K[36m[K:[m[K[32m[K13[m[K[36m[K:[m[K slug = sharkdp/[1;33m[Kbat[m[K

367+[35m[K.git/config[m[K[36m[K:[m[K[32m[K143[m[K[36m[K:[m[K[branch "[1;33m[Kbat[m[K-config-file"]

368+[35m[K.git/config[m[K[36m[K:[m[K[32m[K145[m[K[36m[K:[m[K merge = refs/heads/[1;33m[Kbat[m[K-config-file

369+[35m[K.git/config[m[K[36m[K:[m[K[32m[K176[m[K[36m[K:[m[K[branch "[1;33m[Kbat[m[K-diff"]

370+[35m[K.git/config[m[K[36m[K:[m[K[32m[K178[m[K[36m[K:[m[K merge = refs/heads/[1;33m[Kbat[m[K-diff

371+[35m[K.git/config[m[K[36m[K:[m[K[32m[K228[m[K[36m[K:[m[K remote = git@github.com:lavifb/[1;33m[Kbat[m[K.git

372+[35m[K.git/config[m[K[36m[K:[m[K[32m[K231[m[K[36m[K:[m[K url = https://github.com/lavifb/[1;33m[Kbat[m[K

373+[35m[K.git/config[m[K[36m[K:[m[K[32m[K234[m[K[36m[K:[m[K remote = git@github.com:majecty/[1;33m[Kbat[m[K.git

374+[35m[K.git/config[m[K[36m[K:[m[K[32m[K237[m[K[36m[K:[m[K url = https://github.com/majecty/[1;33m[Kbat[m[K

375+[35m[K.git/config[m[K[36m[K:[m[K[32m[K246[m[K[36m[K:[m[K remote = git@github.com:reidwagner/[1;33m[Kbat[m[K.git

376+[35m[K.git/config[m[K[36m[K:[m[K[32m[K315[m[K[36m[K:[m[K remote = git@github.com:hrlmartins/[1;33m[Kbat[m[K.git

377+[35m[K.git/config[m[K[36m[K:[m[K[32m[K369[m[K[36m[K:[m[K remote = git@github.com:fvictorio/[1;33m[Kbat[m[K.git

378+[35m[K.git/config[m[K[36m[K:[m[K[32m[K378[m[K[36m[K:[m[K remote = git@github.com:eth-p/[1;33m[Kbat[m[K.git

379+[35m[K.git/config[m[K[36m[K:[m[K[32m[K387[m[K[36m[K:[m[K remote = git@github.com:Kogia-sima/[1;33m[Kbat[m[K.git

380+[35m[K.git/config[m[K[36m[K:[m[K[32m[K426[m[K[36m[K:[m[K remote = git@github.com:neuronull/[1;33m[Kbat[m[K.git

381+[35m[K.git/config[m[K[36m[K:[m[K[32m[K429[m[K[36m[K:[m[K remote = git@github.com:jmick414/[1;33m[Kbat[m[K.git

382+[35m[K.git/config[m[K[36m[K:[m[K[32m[K435[m[K[36m[K:[m[K remote = git@github.com:dtolnay/[1;33m[Kbat[m[K.git

383+[35m[K.git/config[m[K[36m[K:[m[K[32m[K441[m[K[36m[K:[m[K remote = git@github.com:eth-p/[1;33m[Kbat[m[K.git

384+[35m[K.git/config[m[K[36m[K:[m[K[32m[K444[m[K[36m[K:[m[K remote = git@github.com:neuronull/[1;33m[Kbat[m[K.git

385+[35m[K.git/config[m[K[36m[K:[m[K[32m[K482[m[K[36m[K:[m[K[branch "[1;33m[Kbat[m[K-diff-fixes"]

386+[35m[K.git/config[m[K[36m[K:[m[K[32m[K484[m[K[36m[K:[m[K merge = refs/heads/[1;33m[Kbat[m[K-diff-fixes

387+[35m[K.git/config[m[K[36m[K:[m[K[32m[K486[m[K[36m[K:[m[K remote = git@github.com:lzutao/[1;33m[Kbat[m[K.git

388+[35m[K.git/config[m[K[36m[K:[m[K[32m[K507[m[K[36m[K:[m[K remote = git@github.com:eth-p/[1;33m[Kbat[m[K.git

389+[35m[K.git/config[m[K[36m[K:[m[K[32m[K510[m[K[36m[K:[m[K remote = git@github.com:eth-p/[1;33m[Kbat[m[K.git

390+[35m[K.git/config[m[K[36m[K:[m[K[32m[K513[m[K[36m[K:[m[K remote = git@github.com:kopecs/[1;33m[Kbat[m[K.git

391+[35m[K.git/config[m[K[36m[K:[m[K[32m[K516[m[K[36m[K:[m[K remote = git@github.com:eth-p/[1;33m[Kbat[m[K.git

392+[35m[K.git/config[m[K[36m[K:[m[K[32m[K540[m[K[36m[K:[m[K remote = git@github.com:rxt1077/[1;33m[Kbat[m[K.git

393+[35m[K.git/config[m[K[36m[K:[m[K[32m[K558[m[K[36m[K:[m[K remote = git@github.com:alexnovak/[1;33m[Kbat[m[K.git

394+[35m[K.git/config[m[K[36m[K:[m[K[32m[K561[m[K[36m[K:[m[K remote = git@github.com:guidocella/[1;33m[Kbat[m[K.git

395+[35m[K.git/config[m[K[36m[K:[m[K[32m[K564[m[K[36m[K:[m[K remote = git@github.com:gsomix/[1;33m[Kbat[m[K.git

396+[35m[K.git/config[m[K[36m[K:[m[K[32m[K567[m[K[36m[K:[m[K remote = git@github.com:caioalonso/[1;33m[Kbat[m[K.git

397+[35m[K.git/config[m[K[36m[K:[m[K[32m[K579[m[K[36m[K:[m[K remote = git@github.com:mk12/[1;33m[Kbat[m[K.git

398+[35m[K.git/config[m[K[36m[K:[m[K[32m[K585[m[K[36m[K:[m[K remote = git@github.com:kjmph/[1;33m[Kbat[m[K.git

399+[35m[K.git/config[m[K[36m[K:[m[K[32m[K591[m[K[36m[K:[m[K remote = git@github.com:Kienyew/[1;33m[Kbat[m[K.git

400+[35m[K.git/config[m[K[36m[K:[m[K[32m[K603[m[K[36m[K:[m[K remote = git@github.com:alexanderkarlis/[1;33m[Kbat[m[K.git

401+[35m[K.git/config[m[K[36m[K:[m[K[32m[K609[m[K[36m[K:[m[K remote = git@github.com:ahmedelgabri/[1;33m[Kbat[m[K.git

402+[35m[K.git/config[m[K[36m[K:[m[K[32m[K615[m[K[36m[K:[m[K remote = git@github.com:Kienyew/[1;33m[Kbat[m[K.git

403+[35m[K.git/config[m[K[36m[K:[m[K[32m[K618[m[K[36m[K:[m[K remote = git@github.com:eth-p/[1;33m[Kbat[m[K.git

404+[35m[K.git/config[m[K[36m[K:[m[K[32m[K620[m[K[36m[K:[m[K[branch "[1;33m[Kbat[m[K-0.16-updates"]

405+[35m[K.git/config[m[K[36m[K:[m[K[32m[K622[m[K[36m[K:[m[K merge = refs/heads/[1;33m[Kbat[m[K-0.16-updates

406+[35m[K.git/config[m[K[36m[K:[m[K[32m[K624[m[K[36m[K:[m[K remote = git@github.com:henil/[1;33m[Kbat[m[K.git

407+[35m[K.git/config[m[K[36m[K:[m[K[32m[K627[m[K[36m[K:[m[K remote = git@github.com:AkshatGadhwal/[1;33m[Kbat[m[K.git

408+[35m[K.git/config[m[K[36m[K:[m[K[32m[K633[m[K[36m[K:[m[K remote = git@github.com:loganintech/[1;33m[Kbat[m[K.git

409+[35m[K.git/config[m[K[36m[K:[m[K[32m[K639[m[K[36m[K:[m[K remote = git@github.com:mzegar/[1;33m[Kbat[m[K.git

410+[35m[K.git/config[m[K[36m[K:[m[K[32m[K642[m[K[36m[K:[m[K remote = git@github.com:AkshatGadhwal/[1;33m[Kbat[m[K.git

411+[35m[K.git/config[m[K[36m[K:[m[K[32m[K645[m[K[36m[K:[m[K remote = git@github.com:AkshatGadhwal/[1;33m[Kbat[m[K.git

412+[35m[K.git/config[m[K[36m[K:[m[K[32m[K651[m[K[36m[K:[m[K remote = git@github.com:jacobmischka/[1;33m[Kbat[m[K.git

413+[35m[K.git/config[m[K[36m[K:[m[K[32m[K657[m[K[36m[K:[m[K url = https://github.com/forkeith/[1;33m[Kbat[m[K.git

414+[35m[K.git/config[m[K[36m[K:[m[K[32m[K660[m[K[36m[K:[m[K remote = git@github.com:ArmandPhilippot/[1;33m[Kbat[m[K.git

415+[35m[K.git/config[m[K[36m[K:[m[K[32m[K664[m[K[36m[K:[m[K url = https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K.git

416+[35m[K.git/config[m[K[36m[K:[m[K[32m[K666[m[K[36m[K:[m[K remote = git@github.com:adrian-rivera/[1;33m[Kbat[m[K.git

417+[35m[K.git/config[m[K[36m[K:[m[K[32m[K669[m[K[36m[K:[m[K remote = git@github.com:eth-p/[1;33m[Kbat[m[K.git

418+[35m[K.git/config[m[K[36m[K:[m[K[32m[K681[m[K[36m[K:[m[K remote = git@github.com:MarcoIeni/[1;33m[Kbat[m[K.git

419+[35m[K.git/config[m[K[36m[K:[m[K[32m[K690[m[K[36m[K:[m[K remote = git@github.com:Enselic/[1;33m[Kbat[m[K.git

420+[35m[K.git/config[m[K[36m[K:[m[K[32m[K696[m[K[36m[K:[m[K remote = git@github.com:stku1985/[1;33m[Kbat[m[K.git

421+[35m[K.git/config[m[K[36m[K:[m[K[32m[K699[m[K[36m[K:[m[K remote = git@github.com:mk12/[1;33m[Kbat[m[K.git

422+[35m[K.git/config[m[K[36m[K:[m[K[32m[K702[m[K[36m[K:[m[K remote = git@github.com:j0hnmeow/[1;33m[Kbat[m[K.git

423+[35m[K.git/config[m[K[36m[K:[m[K[32m[K708[m[K[36m[K:[m[K remote = git@github.com:Enselic/[1;33m[Kbat[m[K.git

424+[35m[K.git/config[m[K[36m[K:[m[K[32m[K713[m[K[36m[K:[m[K[branch "[1;33m[Kbat[m[K-diagnostic-option"]

425+[35m[K.git/config[m[K[36m[K:[m[K[32m[K715[m[K[36m[K:[m[K merge = refs/heads/[1;33m[Kbat[m[K-diagnostic-option

426+[35m[K.git/config[m[K[36m[K:[m[K[32m[K717[m[K[36m[K:[m[K url = https://github.com/niklasmohrin/[1;33m[Kbat[m[K.git

427+[35m[K.git/config[m[K[36m[K:[m[K[32m[K723[m[K[36m[K:[m[K remote = git@github.com:paulsmith/[1;33m[Kbat[m[K.git

428+[35m[K.git/config[m[K[36m[K:[m[K[32m[K735[m[K[36m[K:[m[K remote = git@github.com:Enselic/[1;33m[Kbat[m[K.git

429+[35m[K.git/config[m[K[36m[K:[m[K[32m[K762[m[K[36m[K:[m[K remote = git@github.com:Enselic/[1;33m[Kbat[m[K.git

430+[35m[K.git/config[m[K[36m[K:[m[K[32m[K771[m[K[36m[K:[m[K remote = git@github.com:brightly-salty/[1;33m[Kbat[m[K.git

431+[35m[K.git/config[m[K[36m[K:[m[K[32m[K774[m[K[36m[K:[m[K remote = git@github.com:eth-p/[1;33m[Kbat[m[K.git

432+[35m[K.git/config[m[K[36m[K:[m[K[32m[K804[m[K[36m[K:[m[K remote = git@github.com:matklad/[1;33m[Kbat[m[K.git

433+[35m[K.git/config[m[K[36m[K:[m[K[32m[K827[m[K[36m[K:[m[K[branch "[1;33m[Kbat[m[K-0.18.2-release"]

434+[35m[K.git/config[m[K[36m[K:[m[K[32m[K829[m[K[36m[K:[m[K merge = refs/heads/[1;33m[Kbat[m[K-0.18.2-release

435+[35m[K.git/config[m[K[36m[K:[m[K[32m[K831[m[K[36m[K:[m[K remote = git@github.com:Enselic/[1;33m[Kbat[m[K.git

436+[35m[K.git/config[m[K[36m[K:[m[K[32m[K834[m[K[36m[K:[m[K remote = git@github.com:steffahn/[1;33m[Kbat[m[K.git

437+[35m[K.git/config[m[K[36m[K:[m[K[32m[K837[m[K[36m[K:[m[K remote = git@github.com:SarveshMD/[1;33m[Kbat[m[K.git

438+[35m[K.git/config[m[K[36m[K:[m[K[32m[K840[m[K[36m[K:[m[K remote = git@github.com:Enselic/[1;33m[Kbat[m[K.git

439+[35m[K.git/config[m[K[36m[K:[m[K[32m[K852[m[K[36m[K:[m[K remote = git@github.com:Enselic/[1;33m[Kbat[m[K.git

440+[35m[K.git/config[m[K[36m[K:[m[K[32m[K861[m[K[36m[K:[m[K remote = git@github.com:bojan88/[1;33m[Kbat[m[K.git

441+[35m[K.git/config[m[K[36m[K:[m[K[32m[K870[m[K[36m[K:[m[K remote = git@github.com:Enselic/[1;33m[Kbat[m[K.git

442+[35m[K.git/config[m[K[36m[K:[m[K[32m[K882[m[K[36m[K:[m[K remote = git@github.com:Enselic/[1;33m[Kbat[m[K.git

443+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K- `$[1;33m[KBAT[m[K_CONFIG_DIR` is now a recognized environment variable. It has precedence over `$XDG_CONFIG_HOME`, see #1727 (@billrisher)

444+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K25[m[K[36m[K:[m[K- Include git hash in `[1;33m[Kbat[m[K -V` and `[1;33m[Kbat[m[K --version` output if present. See #1921 (@Enselic)

445+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K42[m[K[36m[K:[m[K## `[1;33m[Kbat[m[K` as a library

446+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K45[m[K[36m[K:[m[K- 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 `[1;33m[Kbat[m[K::assets::build`. See #1802 (@Enselic)

447+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K67[m[K[36m[K:[m[K- Fix for a security vulnerability on Windows. Prior to this release, `[1;33m[Kbat[m[K` would execute programs called `less`/`less.exe` from the current working directory (instead of the one from `PATH`) with priority. An attacker might be able to use this by placing a malicious program in a shared directory where the user would execute `[1;33m[Kbat[m[K`. `[1;33m[Kbat[m[K` users on Windows are advised to upgrade to this version. See #1724 and #1472 (@Ry0taK).

448+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K92[m[K[36m[K:[m[K- The `LESS` environment variable is now included in `[1;33m[Kbat[m[K --diagnostic`, see #1589 (@Enselic)

449+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K98[m[K[36m[K:[m[K- Replaced "Advanced CSV" with a custom CSV syntax definition written especially for `[1;33m[Kbat[m[K`; see #1574 (@keith-hall)

450+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K112[m[K[36m[K:[m[K- Use a pager when `[1;33m[Kbat[m[K --list-languages` is called, see #1394 (@stku1985)

451+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K117[m[K[36m[K:[m[K- Only print themes hint in interactive mode (`[1;33m[Kbat[m[K --list-themes`), see #1439 (@rsteube)

452+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K122[m[K[36m[K:[m[K- If `PAGER` (but not `[1;33m[KBAT[m[K_PAGER` or `--pager`) is `more` or `most`, silently use `less` instead to ensure support for colors, see #1063 (@Enselic)

453+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K123[m[K[36m[K:[m[K- If `PAGER` is `[1;33m[Kbat[m[K`, silently use `less` to prevent recursion. For `[1;33m[KBAT[m[K_PAGER` or `--pager`, exit with error, see #1413 (@Enselic)

454+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K125[m[K[36m[K:[m[K- `[1;33m[KBAT[m[K_CONFIG_PATH` ignored by `[1;33m[Kbat[m[K` if non-existent, see #1550 (@sharkdp)

455+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K147[m[K[36m[K:[m[K## `[1;33m[Kbat[m[K` as a library

456+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K160[m[K[36m[K:[m[K- Running `[1;33m[Kbat[m[K` without arguments fails ("output file is also an input"), see #1396

457+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K168[m[K[36m[K:[m[K- Pass `-S` ("chop long lines") to `less` if `--wrap=never` is set in `[1;33m[Kbat[m[K`, see #1255 (@gahag)

458+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K173[m[K[36m[K:[m[K- Throw an error when `[1;33m[Kbat[m[K` is being used as `pager`, see #1343 (@adrian-rivera)

459+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K225[m[K[36m[K:[m[K## `[1;33m[Kbat[m[K` as a library

460+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K246[m[K[36m[K:[m[K- Cannot run `[1;33m[Kbat[m[K` with relative paths, see #1022

461+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K247[m[K[36m[K:[m[K- [1;33m[Kbat[m[K mishighlights Users that start with digits in SSH config, see #984

462+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K268[m[K[36m[K:[m[K- [1;33m[Kbat[m[K now prints an error if an invalid syntax is specified via `-l` or `--map-syntax`, see #1004 (@eth-p)

463+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K270[m[K[36m[K:[m[K## `[1;33m[Kbat[m[K` as a library

464+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K276[m[K[36m[K:[m[K- Compilation problems with `onig_sys` on various platforms have been resolved by upgrading to `syntect 4.2`, which includes a new `onig` version that allows to build `onig_sys` without the `bindgen` dependency. This removes the need for `libclang(-dev)` to be installed to compile `[1;33m[Kbat[m[K`. Package maintainers might want to remove `clang` as a build dependency. See #650 for more details.

465+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K284[m[K[36m[K:[m[K Users suffering from #865 ("no color for [1;33m[Kbat[m[K in ssh from a Windows client") can use the `ansi-dark` and `ansi-light` themes from now on.

466+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K303[m[K[36m[K:[m[K- Performance improvements when using custom caches (via `[1;33m[Kbat[m[K cache --build`): the `[1;33m[Kbat[m[K` startup time should now be twice as fast (@lzutao).

467+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K309[m[K[36m[K:[m[K## `[1;33m[Kbat[m[K` as a library

468+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K320[m[K[36m[K:[m[K in the header. This is useful when piping input into `[1;33m[Kbat[m[K`. See #654 and #892 (@neuronull).

469+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K336[m[K[36m[K:[m[K- When saving/reading user-provided syntaxes or themes, `[1;33m[Kbat[m[K` will now maintain a

470+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K337[m[K[36m[K:[m[K `metadata.yaml` file which includes information about the `[1;33m[Kbat[m[K` version which was

471+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K342[m[K[36m[K:[m[K## `[1;33m[Kbat[m[K` as a library

472+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K346[m[K[36m[K:[m[K API is still available (basically everything that is not in the root `[1;33m[Kbat[m[K`

473+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K349[m[K[36m[K:[m[K Note that this should still be considered a "beta" release of `[1;33m[Kbat[m[K`-as-a-library.

474+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K354[m[K[36m[K:[m[K everything required by `[1;33m[Kbat[m[K` the application. When depending on [1;33m[Kbat[m[K as a library, downstream

475+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K358[m[K[36m[K:[m[K [1;33m[Kbat[m[K = { version = "0.14", default-features = false }

476+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K371[m[K[36m[K:[m[K## `[1;33m[Kbat[m[K` as a library

477+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K373[m[K[36m[K:[m[KBeginning with this release, `[1;33m[Kbat[m[K` can be used as a library (#423).

478+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K378[m[K[36m[K:[m[K- Second attempt, complete restructuring of the `[1;33m[Kbat[m[K` crate, see #679 (@DrSensor)

479+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K383[m[K[36m[K:[m[KThat being said, you can start using it! See the example programs in [`examples/`](https://github.com/sharkdp/[1;33m[Kbat[m[K/tree/master/examples).

480+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K385[m[K[36m[K:[m[KYou can see the API documentation here: https://docs.rs/[1;33m[Kbat[m[K/

481+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K390[m[K[36m[K:[m[K users need to update their [1;33m[Kbat[m[K config files (`[1;33m[Kbat[m[K --config-file`), if they have any `--map-syntax` settings

482+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K407[m[K[36m[K:[m[K- `[1;33m[KBAT[m[K_CACHE_PATH` can be used to place cached `[1;33m[Kbat[m[K` assets in a non-standard path, see #829 (@neuronull)

483+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K413[m[K[36m[K:[m[K- '[1;33m[Kbat[m[K cache' still takes precedence over existing files, see #666 (@sharkdp)

484+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K425[m[K[36m[K:[m[K- Enabled LTO, making `[1;33m[Kbat[m[K` about 10% faster, see #719 (@bolinfest, @sharkdp)

485+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K426[m[K[36m[K:[m[K- Suggestions non how to configure `[1;33m[Kbat[m[K` for MacOS dark mode, see README (@jerguslejko)

486+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K427[m[K[36m[K:[m[K- Extended ["Integration with other tools"](https://github.com/sharkdp/[1;33m[Kbat[m[K#integration-with-other-tools) section (@eth-p)

487+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K428[m[K[36m[K:[m[K- Updated [instrutions on how to use `[1;33m[Kbat[m[K` as a `man`-pager](https://github.com/sharkdp/[1;33m[Kbat[m[K#man), see #652, see #667 (@sharkdp)

488+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K456[m[K[36m[K:[m[K- `[1;33m[Kbat[m[K` is now in the official Ubuntu and Debian repositories, see #323 and #705 (@MarcoFalke)

489+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K457[m[K[36m[K:[m[K- `[1;33m[Kbat[m[K` can now be installed via MacPorts, see #675 (@bn3t)

490+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K476[m[K[36m[K:[m[K- Binary file content can now be viewed with `[1;33m[Kbat[m[K -A`, see #623, #640 (@pjsier and @sharkdp)

491+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K477[m[K[36m[K:[m[K- `[1;33m[Kbat[m[K` can now be used as a man pager. Take a look at the README and #523 for more details.

492+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K506[m[K[36m[K:[m[K- `[1;33m[Kbat[m[K` is now in the official Gentoo repositories, see #588 (@toku-sa-n)

493+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K507[m[K[36m[K:[m[K- `[1;33m[Kbat[m[K` is now in the official Alpine Linux repositories, see #586 (@5paceToast)

494+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K508[m[K[36m[K:[m[K- `[1;33m[Kbat[m[K` is in the official Fedora repositories, see #610 (@ignatenkobrain)

495+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K534[m[K[36m[K:[m[K- New ["Integration with other tools"](https://github.com/sharkdp/[1;33m[Kbat[m[K#integration-with-other-tools) section in the README.

496+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K544[m[K[36m[K:[m[K- `[1;33m[Kbat[m[K` is now available on Chocolatey, see #541 (@rasmuskriest)

497+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K554[m[K[36m[K:[m[K- **Change the default configuration directory on macOS** to `~/.config/[1;33m[Kbat[m[K`, see #442 (@lavifb). If you are on macOS, you need to copy your configuration directory from the previous place (`~/Library/Preferences/[1;33m[Kbat[m[K`) to the new place (`~/.config/[1;33m[Kbat[m[K`).

498+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K559[m[K[36m[K:[m[K- Rename `[1;33m[Kbat[m[K cache --init` to `[1;33m[Kbat[m[K cache --build`, see #498

499+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K560[m[K[36m[K:[m[K- Move the `--config-dir` and `--cache-dir` options from `[1;33m[Kbat[m[K cache` to `[1;33m[Kbat[m[K` and hide them from the help text.

500+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K596[m[K[36m[K:[m[K- Added `[1;33m[KBAT[m[K_CONFIG_PATH` environment variable to set a non-default path for `[1;33m[Kbat[m[K`s configuration file, see #375 (@deg4uss3r)

501+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K618[m[K[36m[K:[m[K- Avoid endless recursion when `PAGER="[1;33m[Kbat[m[K"`, see #383 (@rodorgas)

502+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K622[m[K[36m[K:[m[K- `[1;33m[Kbat[m[K` is now available on openSUSE, see #405 (@dmarcoux)

503+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K651[m[K[36m[K:[m[K The configuration file path can be accessed via `[1;33m[Kbat[m[K --config-file`. On Linux,

504+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K652[m[K[36m[K:[m[K it is stored in `~/.config/[1;33m[Kbat[m[K/config`.

505+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K654[m[K[36m[K:[m[K- Support for the `[1;33m[KBAT[m[K_OPTS` environment variable with the same format as specified

506+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K664[m[K[36m[K:[m[K [1;33m[Kbat[m[K --map-syntax .config:json ...

507+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K667[m[K[36m[K:[m[K The option can be use multiple times. Note that you can easily make these mappings permanent by using [1;33m[Kbat[m[Ks new configuration file.

508+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K671[m[K[36m[K:[m[K- Support pager command-line arguments in `PAGER` and `[1;33m[KBAT[m[K_PAGER`, see #352 (@Foxboron)

509+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K689[m[K[36m[K:[m[K- [1;33m[KBat[m[K Panics on Haskell Source Code, see #314

510+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K695[m[K[36m[K:[m[K- Updated documentation on how to configure `[1;33m[Kbat[m[K`s pager

511+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K703[m[K[36m[K:[m[K- `[1;33m[Kbat[m[K` is now available via [Termux](https://termux.com/), see #341 (@fornwall)

512+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K705[m[K[36m[K:[m[K- `[1;33m[Kbat[m[K` is now available via [nix](https://nixos.org/nix), see #344 (@mgttlinger)

513+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K707[m[K[36m[K:[m[K- `[1;33m[Kbat[m[K` is now available via [Docker](https://hub.docker.com/r/danlynn/[1;33m[Kbat[m[K/), see #331 (@danlynn)

514+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K717[m[K[36m[K:[m[K- [1;33m[KBat[m[K Panics on Haskell Source Code, see #314

515+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K730[m[K[36m[K:[m[K `--tabs` command-line option or the `[1;33m[KBAT[m[K_TABS` environment variable. The

516+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K733[m[K[36m[K:[m[K- Added support for the `[1;33m[KBAT[m[K_STYLE` environment variable, see #208 (@ms2300)

517+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K764[m[K[36m[K:[m[K- Added README section about "`[1;33m[Kbat[m[K` on Windows" (@Aankhen)

518+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K772[m[K[36m[K:[m[K- Fixed panic when running `[1;33m[Kbat[m[K --list-languages | head`, see #232 (@mchlrhw)

519+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K786[m[K[36m[K:[m[K- Major refactorings, enabling some progress on #150. In non-interactive mode, `[1;33m[Kbat[m[K` will now copy input bytes 1:1.

520+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K792[m[K[36m[K:[m[K- New themes in `$[1;33m[KBAT[m[K_CONFIG_DIR/themes` are now loaded *in addition* to

521+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K798[m[K[36m[K:[m[K* Using `[1;33m[Kbat[m[K cache --init` leads to duplicated syntaxes, see #206

522+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K811[m[K[36m[K:[m[K- The syntax highlighting theme can now be controlled by the `[1;33m[KBAT[m[K_THEME` environment variable, see [README](https://github.com/sharkdp/[1;33m[Kbat[m[K#highlighting-theme) and #177 (@mandx)

523+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K812[m[K[36m[K:[m[K- The `PAGER` and `[1;33m[KBAT[m[K_PAGER` environment variables can be used to control the pager that `[1;33m[Kbat[m[K` uses, see #158 and the [new README section](https://github.com/sharkdp/[1;33m[Kbat[m[K#using-a-different-pager)

524+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K818[m[K[36m[K:[m[K- The customization of syntax sets and theme sets is now separated. Syntax definitions are now loaded *in addition* to the ones that are stored in the `[1;33m[Kbat[m[K` binary by default. Please refer to these new sections in the README: [Adding new syntaxes](https://github.com/sharkdp/[1;33m[Kbat[m[K#adding-new-syntaxes--language-definitions), [Adding new themes](https://github.com/sharkdp/[1;33m[Kbat[m[K#adding-new-themes), also see #172

525+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K830[m[K[36m[K:[m[K- `[1;33m[Kbat[m[K` is now in the official [Arch package repositories](https://www.archlinux.org/packages/community/x86_64/[1;33m[Kbat[m[K/).

526+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K839[m[K[36m[K:[m[K- Fix problem with `cargo test` when `[1;33m[Kbat[m[K` is not checked out in a Git repository, see #161

527+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K874[m[K[36m[K:[m[K- [Comparison with alternative projects](https://github.com/sharkdp/[1;33m[Kbat[m[K/blob/master/doc/alternatives.md).

528+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K875[m[K[36m[K:[m[K- New "[1;33m[Kbat[m[K" logo in the README, see #119 (@jraulhernandezi)

529+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K895[m[K[36m[K:[m[K `[1;33m[Kbat[m[K cache`. See `[1;33m[Kbat[m[K cache -h` for all available commands.

530+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K900[m[K[36m[K:[m[K* Process substitution can now be used with [1;33m[Kbat[m[K (`[1;33m[Kbat[m[K <(echo a) <(echo b)`), see #80

531+[35m[KCHANGELOG.md[m[K[36m[K:[m[K[32m[K912[m[K[36m[K:[m[K- Added a new statically linked version of [1;33m[Kbat[m[K (`..-musl-..`)

532+[35m[KCONTRIBUTING.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[KThank you for considering to contribute to `[1;33m[Kbat[m[K`!

533+[35m[KCONTRIBUTING.md[m[K[36m[K:[m[K[32m[K9[m[K[36m[K:[m[KIf your contribution changes the behavior of `[1;33m[Kbat[m[K` (as opposed to a typo-fix

534+[35m[KCONTRIBUTING.md[m[K[36m[K:[m[K[32m[K12[m[K[36m[K:[m[Ktherefore helps to get your changes into a new `[1;33m[Kbat[m[K` release faster.

535+[35m[KCONTRIBUTING.md[m[K[36m[K:[m[K[32m[K28[m[K[36m[K:[m[KPlease check out the [Development](https://github.com/sharkdp/[1;33m[Kbat[m[K#development)

536+[35m[KCONTRIBUTING.md[m[K[36m[K:[m[K[32m[K35[m[K[36m[K:[m[K[feature request ticket](https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/new?assignees=&labels=feature-request&template=feature_request.md)

537+[35m[KCONTRIBUTING.md[m[K[36m[K:[m[K[32m[K42[m[K[36m[K:[m[Kthe [Customization](https://github.com/sharkdp/[1;33m[Kbat[m[K#customization) section

538+[35m[KCONTRIBUTING.md[m[K[36m[K:[m[K[32m[K47[m[K[36m[K:[m[K[documentation](https://github.com/sharkdp/[1;33m[Kbat[m[K/blob/master/doc/assets.md)

539+[35m[KCargo.toml[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[Khomepage = "https://github.com/sharkdp/[1;33m[Kbat[m[K"

540+[35m[KCargo.toml[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[Kname = "[1;33m[Kbat[m[K"

541+[35m[KCargo.toml[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[Krepository = "https://github.com/sharkdp/[1;33m[Kbat[m[K"

542+[35m[KCargo.toml[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[K# Feature required for [1;33m[Kbat[m[K the application. Should be disabled when depending on

543+[35m[KCargo.toml[m[K[36m[K:[m[K[32m[K17[m[K[36m[K:[m[K# [1;33m[Kbat[m[K as a library.

544+[35m[KCargo.toml[m[K[36m[K:[m[K[32m[K40[m[K[36m[K:[m[K# You need to use one of these if you depend on [1;33m[Kbat[m[K as a library:

545+[35m[Kdoc/fzf-preview.sh[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K [1;33m[Kbat[m[K \

546+[35m[Kdoc/preview.sh[m[K[36m[K:[m[K[32m[K47[m[K[36m[K:[m[K[1;33m[Kbat[m[K --color always \

547+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[KShould you find that a particular syntax is not available within `[1;33m[Kbat[m[K` and think it should be included in `[1;33m[Kbat[m[K` by default, you can follow the instructions outlined below.

548+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` uses the excellent [syntect](https://github.com/trishume/syntect) library to highlight source

549+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K20[m[K[36m[K:[m[K3. Run the `assets/create.sh` script. It calls `[1;33m[Kbat[m[K cache --build` to parse all available

550+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K23[m[K[36m[K:[m[K4. Re-compile `[1;33m[Kbat[m[K`. At compilation time, the `syntaxes.bin` file will be stored inside the

551+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K24[m[K[36m[K:[m[K `[1;33m[Kbat[m[K` binary.

552+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K26[m[K[36m[K:[m[K5. Use `[1;33m[Kbat[m[K --list-languages` to check if the new languages are available.

553+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K31[m[K[36m[K:[m[K file. A new binary cache file will be created once before every new release of `[1;33m[Kbat[m[K`. This

554+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K36[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` has a set of syntax highlighting regression tests in `tests/syntax-tests`. The main idea is

555+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K38[m[K[36m[K:[m[Kfor some language is suddenly not working anymore or (2) `[1;33m[Kbat[m[K` suddenly crashes for some input (due

556+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K43[m[K[36m[K:[m[K1. Make sure that you are running the **latest version of `[1;33m[Kbat[m[K`** and that `[1;33m[Kbat[m[K` is available on

557+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K45[m[K[36m[K:[m[K your version of `[1;33m[Kbat[m[K` already has the new syntax builtin.

558+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K50[m[K[36m[K:[m[K be `test.rb` (adapt extension) but can also be adapted if that is necessary in order for `[1;33m[Kbat[m[K` to

559+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K53[m[K[36m[K:[m[K under the respective license and that the license is compatible with `[1;33m[Kbat[m[K`s license. If it

560+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K62[m[K[36m[K:[m[K6. Use `cat` or `[1;33m[Kbat[m[K --language=txt` to display the content of this file and make sure that the

561+[35m[Kdoc/assets.md[m[K[36m[K:[m[K[32m[K70[m[K[36m[K:[m[Kthemes (`[1;33m[Kbat[m[K cache --clear`).

562+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[K <img src="logo-header.svg" alt="[1;33m[Kbat[m[K - a cat clone with wings">

563+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K <a href="https://github.com/sharkdp/[1;33m[Kbat[m[K/actions?query=workflow%3ACICD"><img src="https://github.com/sharkdp/[1;33m[Kbat[m[K/workflows/CICD/badge.svg" alt="Build Status"></a>

564+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K <img src="https://img.shields.io/crates/l/[1;33m[Kbat[m[K.svg" alt="license">

565+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K <a href="https://crates.io/crates/[1;33m[Kbat[m[K"><img src="https://img.shields.io/crates/v/[1;33m[Kbat[m[K.svg?colorB=319e8c" alt="Version info"></a>

566+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[K [<a href="https://github.com/chinanf-boy/[1;33m[Kbat[m[K-zh">中文</a>]

567+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K24[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` は多くのプログラミング言語やマークアップ言語の

568+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K31[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` は `git` とも連携しており、差分を表現する記号が表示されます

569+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K45[m[K[36m[K:[m[K出力が1つの画面に対して大きすぎる場合、`[1;33m[Kbat[m[K` は自身の出力をページャー(例えば `less`) にパイプで繋げます。

570+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K50[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` は非対話型のターミナルを検出すると(すなわち他のプロセスにパイプしたりファイル出力していると)、

571+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K51[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` は `cat` の完全互換として振る舞い、

572+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K59[m[K[36m[K:[m[K> [1;33m[Kbat[m[K README.md

573+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K65[m[K[36m[K:[m[K> [1;33m[Kbat[m[K src/*.rs

574+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K73[m[K[36m[K:[m[K> curl -s https://sh.rustup.rs | [1;33m[Kbat[m[K

575+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K79[m[K[36m[K:[m[K> yaml2json .travis.yml | json_pp | [1;33m[Kbat[m[K -l json

576+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K84[m[K[36m[K:[m[K> [1;33m[Kbat[m[K -A /etc/hosts

577+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K87[m[K[36m[K:[m[K`cat` の代わりに `[1;33m[Kbat[m[K` を使用する際の例:

578+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K90[m[K[36m[K:[m[K[1;33m[Kbat[m[K > note.md # quickly create a new file

579+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K92[m[K[36m[K:[m[K[1;33m[Kbat[m[K header.md content.md footer.md > document.md

580+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K94[m[K[36m[K:[m[K[1;33m[Kbat[m[K -n main.rs # show line numbers (only)

581+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K96[m[K[36m[K:[m[K[1;33m[Kbat[m[K f - g # output 'f', then stdin, then 'g'.

582+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K103[m[K[36m[K:[m[K[`fzf`](https://github.com/junegunn/fzf) のプレビューウィンドウに `[1;33m[Kbat[m[K` を使用できます。

583+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K104[m[K[36m[K:[m[Kその場合、`[1;33m[Kbat[m[K` の `--color=always` オプションを用いてカラー出力を強制しなければなりません。

584+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K107[m[K[36m[K:[m[Kfzf --preview '[1;33m[Kbat[m[K --color=always --style=numbers --line-range=:500 {}'

585+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K114[m[K[36m[K:[m[K`find` の `-exec` オプションを使用して、`[1;33m[Kbat[m[K` ですべての検索結果をプレビューできます:

586+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K116[m[K[36m[K:[m[Kfind … -exec [1;33m[Kbat[m[K {} +

587+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K119[m[K[36m[K:[m[K[`fd`](https://github.com/sharkdp/fd) を使用している場合は、`-X` /`-exec-[1;33m[Kbat[m[Kch` オプションを使用して同じことを行うことができます:

588+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K121[m[K[36m[K:[m[Kfd … -X [1;33m[Kbat[m[K

589+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K126[m[K[36m[K:[m[K[`[1;33m[Kbat[m[Kgrep`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras/blob/master/doc/[1;33m[Kbat[m[Kgrep.md) では、[`ripgrep`](https://github.com/BurntSushi/ripgrep) 検索結果のプリンターとして `[1;33m[Kbat[m[K` を使用できます。

590+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K129[m[K[36m[K:[m[K[1;33m[Kbat[m[Kgrep needle src/

591+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K134[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` を `tail -f` と組み合わせて、構文強調表示を使用して特定のファイルを継続的に監視できます。

592+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K136[m[K[36m[K:[m[Ktail -f /var/log/pacman.log | [1;33m[Kbat[m[K --paging=never -l log

593+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K142[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` を `git show` と組み合わせて、

594+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K145[m[K[36m[K:[m[Kgit show v0.6.0:src/main.rs | [1;33m[Kbat[m[K -l rs

595+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K152[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` の出力の行番号と Git 変更マーカーにより、ファイルの内容をコピーするのが難しくなる場合があります。

596+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K153[m[K[36m[K:[m[Kこれを防ぐには、`-p` / `-plain` オプションを使用して `[1;33m[Kbat[m[K` を呼び出すか、

597+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K156[m[K[36m[K:[m[K[1;33m[Kbat[m[K main.cpp | xclip

598+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K158[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` は出力がリダイレクトされていることを検出し、プレーンファイルの内容を出力します。

599+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K162[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` は `MANPAGER` 環境変数を設定することにより、

600+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K166[m[K[36m[K:[m[Kexport MANPAGER="sh -c 'col -bx | [1;33m[Kbat[m[K -l man -p'"

601+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K173[m[K[36m[K:[m[Kこれを新しいコマンドにバンドルしたい場合は [`[1;33m[Kbat[m[Kman`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras/blob/master/doc/[1;33m[Kbat[m[Kman.md) も使用できます。

602+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K179[m[K[36m[K:[m[K[`pretty[1;33m[Kbat[m[K`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras/blob/master/doc/pretty[1;33m[Kbat[m[K.md) スクリプトは、コードをフォーマットし、`[1;33m[Kbat[m[K` で印刷するラッパーです。

603+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K184[m[K[36m[K:[m[K[![Packaging status](https://repology.org/badge/vertical-allrepos/[1;33m[Kbat[m[K.svg)](https://repology.org/project/[1;33m[Kbat[m[K/versions)

604+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K189[m[K[36m[K:[m[KUbuntu Eoan 19.10 または Debian 不安定版 sid 以降の [the Ubuntu `[1;33m[Kbat[m[K` package](https://packages.ubuntu.com/eoan/[1;33m[Kbat[m[K) または [the Debian `[1;33m[Kbat[m[K` package](https://packages.debian.org/sid/[1;33m[Kbat[m[K) からインストールできます:

605+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K192[m[K[36m[K:[m[Kapt install [1;33m[Kbat[m[K

606+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K195[m[K[36m[K:[m[K`apt` を使用して `[1;33m[Kbat[m[K` をインストールした場合、実行可能ファイルの名前が `[1;33m[Kbat[m[K` ではなく `[1;33m[Kbat[m[Kcat` になることがあります([他のパッケージとの名前衝突のため](https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/982))。`[1;33m[Kbat[m[K -> [1;33m[Kbat[m[Kcat` のシンボリックリンクまたはエイリアスを設定することで、実行可能ファイル名が異なることによる問題の発生を防ぎ、他のディストリビューションと一貫性を保てます。

607+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K199[m[K[36m[K:[m[Kln -s /usr/bin/[1;33m[Kbat[m[Kcat ~/.local/bin/[1;33m[Kbat[m[K

608+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K205[m[K[36m[K:[m[K[1;33m[Kbat[m[Kの最新リリースを実行する場合、または Ubuntu/Debian の古いバージョンを使用している場合は、[release page](https://github.com/sharkdp/[1;33m[Kbat[m[K/releases) から最新の `.deb` パッケージをダウンロードし、

609+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K208[m[K[36m[K:[m[Ksudo dpkg -i [1;33m[Kbat[m[K_0.18.3_amd64.deb # adapt version number and architecture

610+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K214[m[K[36m[K:[m[K公式のソースから [`[1;33m[Kbat[m[K` package](https://pkgs.alpinelinux.org/packages?name=[1;33m[Kbat[m[K) をインストールできます:

611+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K217[m[K[36m[K:[m[Kapk add [1;33m[Kbat[m[K

612+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K222[m[K[36m[K:[m[K[Arch Linuxの公式リソース](https://www.archlinux.org/packages/community/x86_64/[1;33m[Kbat[m[K/)

613+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K226[m[K[36m[K:[m[Kpacman -S [1;33m[Kbat[m[K

614+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K231[m[K[36m[K:[m[K公式の [Fedora Modular](https://docs.fedoraproject.org/en-US/modularity/using-modules/) リポジトリから [the `[1;33m[Kbat[m[K` package](https://koji.fedoraproject.org/koji/packageinfo?packageID=27506) をインストールできます。

615+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K234[m[K[36m[K:[m[Kdnf install [1;33m[Kbat[m[K

616+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K240[m[K[36m[K:[m[K[the `[1;33m[Kbat[m[K` package](https://packages.gentoo.org/packages/sys-apps/[1;33m[Kbat[m[K) をインストールできます。

617+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K243[m[K[36m[K:[m[Kemerge sys-apps/[1;33m[Kbat[m[K

618+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K248[m[K[36m[K:[m[Kxbps-install経由で `[1;33m[Kbat[m[K` をインストールできます。

619+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K250[m[K[36m[K:[m[Kxbps-install -S [1;33m[Kbat[m[K

620+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K255[m[K[36m[K:[m[Kpkg を使用してプリコンパイルされた [`[1;33m[Kbat[m[K` package](https://www.freshports.org/textproc/[1;33m[Kbat[m[K) をインストールできます:

621+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K258[m[K[36m[K:[m[Kpkg install [1;33m[Kbat[m[K

622+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K264[m[K[36m[K:[m[Kcd /usr/ports/textproc/[1;33m[Kbat[m[K

623+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K270[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` を [nix package manager](https://nixos.org/nix) 経由でインストールすることができます:

624+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K273[m[K[36m[K:[m[Knix-env -i [1;33m[Kbat[m[K

625+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K278[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` をzypperでインストールすることができます:

626+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K281[m[K[36m[K:[m[Kzypper install [1;33m[Kbat[m[K

627+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K286[m[K[36m[K:[m[K[Homebrew](http://braumeister.org/formula/[1;33m[Kbat[m[K)で `[1;33m[Kbat[m[K` をインストールできます:

628+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K289[m[K[36m[K:[m[Kbrew install [1;33m[Kbat[m[K

629+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K292[m[K[36m[K:[m[Kまたは [MacPorts](https://ports.macports.org/port/[1;33m[Kbat[m[K/summary) で `[1;33m[Kbat[m[K` をインストールします:

630+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K295[m[K[36m[K:[m[Kport install [1;33m[Kbat[m[K

631+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K300[m[K[36m[K:[m[KWindowsに[1;33m[Kbat[m[Kをインストールするいくつかのオプションがあります。

632+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K301[m[K[36m[K:[m[K[1;33m[Kbat[m[Kをインストールしたら [Windowsでの[1;33m[Kbat[m[Kの使用](#windows-での-[1;33m[Kbat[m[K-の利用) セクションをご覧ください。

633+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K305[m[K[36m[K:[m[K[Chocolatey](https://chocolatey.org/packages/[1;33m[KBat[m[K) から `[1;33m[Kbat[m[K` をインストールできます:

634+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K307[m[K[36m[K:[m[Kchoco install [1;33m[Kbat[m[K

635+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K312[m[K[36m[K:[m[K[scoop](https://scoop.sh/) から `[1;33m[Kbat[m[K` をインストールできます:

636+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K314[m[K[36m[K:[m[Kscoop install [1;33m[Kbat[m[K

637+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K321[m[K[36m[K:[m[K[リリースページ](https://github.com/sharkdp/[1;33m[Kbat[m[K/releases) からビルド済みのバイナリをダウンロードできます。

638+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K327[m[K[36m[K:[m[Kコンテナ内で `[1;33m[Kbat[m[K` を使いたい方のために [Docker image](https://hub.docker.com/r/danlynn/[1;33m[Kbat[m[K/) が用意されています:

639+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K329[m[K[36m[K:[m[Kdocker pull danlynn/[1;33m[Kbat[m[K

640+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K330[m[K[36m[K:[m[Kalias [1;33m[Kbat[m[K='docker run -it --rm -e [1;33m[KBAT[m[K_THEME -e [1;33m[KBAT[m[K_STYLE -e [1;33m[KBAT[m[K_TABS -v "$(pwd):/myapp" danlynn/[1;33m[Kbat[m[K'

641+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K339[m[K[36m[K:[m[Kansible-galaxy install aeimer.install_[1;33m[Kbat[m[K

642+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K344[m[K[36m[K:[m[K# Playbook to install [1;33m[Kbat[m[K

643+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K347[m[K[36m[K:[m[K - aeimer.install_[1;33m[Kbat[m[K

644+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K350[m[K[36m[K:[m[K- [Ansible Galaxy](https://galaxy.ansible.com/aeimer/install_[1;33m[Kbat[m[K)

645+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K351[m[K[36m[K:[m[K- [GitHub](https://github.com/aeimer/ansible-install-[1;33m[Kbat[m[K)

646+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K364[m[K[36m[K:[m[K多くの異なるアーキテクチャのためのプレビルドバージョンを[リリースページ](https://github.com/sharkdp/[1;33m[Kbat[m[K/releases)からチェックしてみてください。静的にリンクされている多くのバイナリも利用できます: ファイル名に `musl` を含むアーカイブを探してみてください。

647+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K369[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` をソースからビルドしたいならば、Rust 1.36 以上の環境が必要です。

648+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K373[m[K[36m[K:[m[Kcargo install --locked [1;33m[Kbat[m[K

649+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K382[m[K[36m[K:[m[K`[1;33m[Kbat[m[K --list-themes` を使うと現在利用可能なシンタックスハイライトのテーマを入手できます。

650+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K384[m[K[36m[K:[m[K`--theme=TwoDark` オプションをつけるか `[1;33m[KBAT[m[K_THEME` という環境変数に

651+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K385[m[K[36m[K:[m[K`TwoDark` を代入する必要があります。シェルの起動ファイルに `export [1;33m[KBAT[m[K_THEME="TwoDark"`

652+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K386[m[K[36m[K:[m[Kと定義すればその設定が変わることはないでしょう。あるいは、 `[1;33m[Kbat[m[K` の

653+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K392[m[K[36m[K:[m[K[1;33m[Kbat[m[K --list-themes | fzf --preview="[1;33m[Kbat[m[K --theme={} --color=always /path/to/file"

654+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K395[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` はデフォルトだと黒い背景色のターミナルに適しています。

655+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K402[m[K[36m[K:[m[K`--style` を使うことで `[1;33m[Kbat[m[K` の表示の見た目を変更することができます。

656+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K405[m[K[36m[K:[m[K環境変数に `[1;33m[KBAT[m[K_STYLE` を定義するとこれらの設定を永続的に使用することができます。

657+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K410[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` はシンタックスハイライトのための [`syntect`](https://github.com/trishume/syntect/)

658+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K418[m[K[36m[K:[m[Kmkdir -p "$([1;33m[Kbat[m[K --config-dir)/syntaxes"

659+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K419[m[K[36m[K:[m[Kcd "$([1;33m[Kbat[m[K --config-dir)/syntaxes"

660+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K429[m[K[36m[K:[m[K[1;33m[Kbat[m[K cache --build

661+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K432[m[K[36m[K:[m[K最後に `[1;33m[Kbat[m[K --list-languages` と入力すると新しい言語が利用可能かどうかチェックします。

662+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K437[m[K[36m[K:[m[K[1;33m[Kbat[m[K cache --clear

663+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K446[m[K[36m[K:[m[Kmkdir -p "$([1;33m[Kbat[m[K --config-dir)/themes"

664+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K447[m[K[36m[K:[m[Kcd "$([1;33m[Kbat[m[K --config-dir)/themes"

665+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K453[m[K[36m[K:[m[K[1;33m[Kbat[m[K cache --build

666+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K456[m[K[36m[K:[m[K最後に、 `[1;33m[Kbat[m[K --list-themes` で新しいテーマが利用可能かチェックします

667+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K460[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` は環境変数 `PAGER` に使用するページャーを明記します。

668+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K463[m[K[36m[K:[m[Kまたは、`PAGER` を上書きする環境変数として `[1;33m[KBAT[m[K_PAGER` を定義することも可能です。

669+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K466[m[K[36m[K:[m[K`PAGER`/`[1;33m[KBAT[m[K_PAGER` 環境変数を定義してください:

670+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K469[m[K[36m[K:[m[Kexport [1;33m[KBAT[m[K_PAGER="less -RF"

671+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K472[m[K[36m[K:[m[K環境変数を利用する代わりに、 `[1;33m[Kbat[m[K` の [設定ファイル](#設定ファイル) を使用して設定も可能です（`--pager` オプション）

672+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K475[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` はページャーの以下のコマンドラインオプションを受け付けるでしょう:

673+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K491[m[K[36m[K:[m[KmacOSでダークモード機能を使用する場合、OSテーマに基づいて異なるテーマを使用するように `[1;33m[Kbat[m[K` を構成することができます。

674+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K496[m[K[36m[K:[m[Kalias cat="[1;33m[Kbat[m[K --theme=\$(defaults read -globalDomain AppleInterfaceStyle &> /dev/null && echo default || echo GitHub)"

675+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K501[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` は設定ファイルでカスタマイズすることが可能です。ファイルの場所はOSに依存します。

676+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K504[m[K[36m[K:[m[K[1;33m[Kbat[m[K --config-file

677+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K507[m[K[36m[K:[m[Kまたは、`[1;33m[KBAT[m[K_CONFIG_PATH` 環境変数を使用して、`[1;33m[Kbat[m[K` が

678+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K510[m[K[36m[K:[m[Kexport [1;33m[KBAT[m[K_CONFIG_PATH="/path/to/[1;33m[Kbat[m[K.conf"

679+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K515[m[K[36m[K:[m[Kこの設定ファイルはコマンドライン引数の単純なリストです。 `[1;33m[Kbat[m[K --help` を利用すると、利用可能なオプションとその値を閲覧することができます。さらに、`#` でコメント文を加えることができます。

680+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K535[m[K[36m[K:[m[K## Windows での `[1;33m[Kbat[m[K` の利用

681+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K537[m[K[36m[K:[m[KWindows 上で `[1;33m[Kbat[m[K` はほとんど動作しますが、いくつかの機能は設定を必要をする場合があります。

682+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K555[m[K[36m[K:[m[K`[1;33m[KBAT[m[K_PAGER` に空文字を設定することでページングを完全に無効にできます。

683+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K559[m[K[36m[K:[m[KWindows上の `[1;33m[Kbat[m[K` は Cygwin のunix風のpath(`/cygdrive/*`)をネイティブサポートしていません。絶対的なcygwinパスを引数として受けたときに、 `[1;33m[Kbat[m[K` は以下のエラーを返すでしょう: `The system cannot find the path specified. (os error 3)`

684+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K564[m[K[36m[K:[m[K[1;33m[Kbat[m[K() {

685+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K573[m[K[36m[K:[m[K command [1;33m[Kbat[m[K "${args[@]}"

686+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K581[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` はターミナルがトゥルーカラーをサポートしている/していないに関係なくサポートします。

687+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K588[m[K[36m[K:[m[K`24bit` のどちらかを代入してください。さもなければ、`[1;33m[Kbat[m[K` はどの色を使うのか決定することができません。または、24-bit エスケープシーケンスがサポートされません

688+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K593[m[K[36m[K:[m[K異なるテーマを試してみてください（`[1;33m[Kbat[m[K --list-themes` でテーマを閲覧できます）。

689+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K598[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` は UTF-16 と同様に UTF-8 をネイティブにサポートします。

690+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K603[m[K[36m[K:[m[Kiconv -f ISO-8859-1 -t UTF-8 my-file.php | [1;33m[Kbat[m[K

691+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K605[m[K[36m[K:[m[K注: `[1;33m[Kbat[m[K` が構文を自動検出できない場合は

692+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K612[m[K[36m[K:[m[Kgit clone --recursive https://github.com/sharkdp/[1;33m[Kbat[m[K

693+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K615[m[K[36m[K:[m[Kcd [1;33m[Kbat[m[K

694+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K624[m[K[36m[K:[m[K# Build a [1;33m[Kbat[m[K binary with modified syntaxes and themes

695+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K636[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` は以下の目標を達成しようと試みています:

697+[35m[Kdoc/README-ja.md[m[K[36m[K:[m[K[32m[K649[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` は MIT License 及び Apache License 2.0 の両方の条件の下で配布されています。

698+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[K <img src="logo-header.svg" alt="[1;33m[Kbat[m[K - a cat clone with wings">

699+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K <a href="https://github.com/sharkdp/[1;33m[Kbat[m[K/actions?query=workflow%3ACICD"><img src="https://github.com/sharkdp/[1;33m[Kbat[m[K/workflows/CICD/badge.svg" alt="Build Status"></a>

700+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K <img src="https://img.shields.io/crates/l/[1;33m[Kbat[m[K.svg" alt="license">

701+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K <a href="https://crates.io/crates/[1;33m[Kbat[m[K"><img src="https://img.shields.io/crates/v/[1;33m[Kbat[m[K.svg?colorB=319e8c" alt="Version info"></a>

702+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[K [<a href="https://github.com/chinanf-boy/[1;33m[Kbat[m[K-zh">中文</a>]

703+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K24[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`은 다양한 프로그래밍 및 마크업 언어의 문법 강조(syntax highlighting) 기능을

704+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K31[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`은 `git`을 통해 인덱스와 함께 변경분을 표시합니다

705+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K44[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`은 기본적으로 한 화면에 비해 출력이 큰 경우 `less`와 같은 페이저(pager)로

706+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K46[m[K[36m[K:[m[K만약 `[1;33m[Kbat[m[K`을 언제나 `cat`처럼 작동하게 하려면 (출력을 페이지하지 않기),

707+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K48[m[K[36m[K:[m[K셸(shell) 설정에서 `cat`을 `[1;33m[Kbat[m[K`의 alias로 사용하려면,

708+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K49[m[K[36m[K:[m[K`alias cat='[1;33m[Kbat[m[K --paging=never'`를 써서 기본 행동을 유지할 수 있습니다.

709+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K53[m[K[36m[K:[m[K페이저(pager)를 사용하더라도 `[1;33m[Kbat[m[K`은 파일들을 연결(concatenate)할 수 있습니다

710+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K55[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`이 비대화형(non-interactive) 터미널(예를 들어, 다른 프로세스나 파일에

711+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K56[m[K[36m[K:[m[K연결(pipe)한 경우)을 감지하면, `[1;33m[Kbat[m[K`은 `--pager` 옵션의 값과 상관없이 `cat`과

712+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K64[m[K[36m[K:[m[K> [1;33m[Kbat[m[K README.md

713+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K70[m[K[36m[K:[m[K> [1;33m[Kbat[m[K src/*.rs

714+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K78[m[K[36m[K:[m[K> curl -s https://sh.rustup.rs | [1;33m[Kbat[m[K

715+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K84[m[K[36m[K:[m[K> yaml2json .travis.yml | json_pp | [1;33m[Kbat[m[K -l json

716+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K89[m[K[36m[K:[m[K> [1;33m[Kbat[m[K -A /etc/hosts

717+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K95[m[K[36m[K:[m[K[1;33m[Kbat[m[K > note.md # quickly create a new file

718+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K97[m[K[36m[K:[m[K[1;33m[Kbat[m[K header.md content.md footer.md > document.md

719+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K99[m[K[36m[K:[m[K[1;33m[Kbat[m[K -n main.rs # show line numbers (only)

720+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K101[m[K[36m[K:[m[K[1;33m[Kbat[m[K f - g # output 'f', then stdin, then 'g'.

721+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K108[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`을 [`fzf`](https://github.com/junegunn/fzf)의 프리뷰로 쓸 수 있습니다.

722+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K109[m[K[36m[K:[m[K이를 위해서는 `[1;33m[Kbat[m[K`의 `--color=always` 옵션으로 항상 컬러 출력이 나오게 해야

723+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K113[m[K[36m[K:[m[Kfzf --preview '[1;33m[Kbat[m[K --color=always --style=numbers --line-range=:500 {}'

724+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K120[m[K[36m[K:[m[K`find`의 `-exec` 옵션을 사용하여 모든 검색 결과를 `[1;33m[Kbat[m[K`로 미리 볼 수 있습니다:

725+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K122[m[K[36m[K:[m[Kfind … -exec [1;33m[Kbat[m[K {} +

726+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K125[m[K[36m[K:[m[K[`fd`](https://github.com/sharkdp/fd)를 사용하는 경우, `-X`/`--exec-[1;33m[Kbat[m[Kch`

727+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K128[m[K[36m[K:[m[Kfd … -X [1;33m[Kbat[m[K

728+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K133[m[K[36m[K:[m[K[`[1;33m[Kbat[m[Kgrep`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras/blob/master/doc/[1;33m[Kbat[m[Kgrep.md)을

729+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K134[m[K[36m[K:[m[K통해 `[1;33m[Kbat[m[K`로 [`ripgrep`](https://github.com/BurntSushi/ripgrep)의 검색 결과를

730+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K138[m[K[36m[K:[m[K[1;33m[Kbat[m[Kgrep needle src/

731+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K143[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`와 `tail -f`를 함께 사용하여 주어진 파일을 문법 강조하며 지속적으로

732+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K146[m[K[36m[K:[m[Ktail -f /var/log/pacman.log | [1;33m[Kbat[m[K --paging=never -l log

733+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K154[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`과 `git show`를 함께 사용하여 주어진 파일의 이전 버전을 올바른 문법 강조로

734+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K157[m[K[36m[K:[m[Kgit show v0.6.0:src/main.rs | [1;33m[Kbat[m[K -l rs

735+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K162[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`과 `git diff`를 함께 사용하여 수정된 코드 주위의 줄들을 올바른 문법 강조로

736+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K165[m[K[36m[K:[m[K[1;33m[Kbat[m[Kdiff() {

737+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K166[m[K[36m[K:[m[K git diff --name-only --diff-filter=d | xargs [1;33m[Kbat[m[K --diff

738+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K170[m[K[36m[K:[m[K[`[1;33m[Kbat[m[K-extras`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras)의 `[1;33m[Kbat[m[Kdiff`를 확인해 보세요.

739+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K177[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` 출력에 줄 번호와 Git 수정 내역이 포함되어서 파일의 내용을 복사하기

740+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K179[m[K[36m[K:[m[K이 경우에는 `[1;33m[Kbat[m[K`의 `-p`/`--plain` 옵션을 사용하거나 간단히 `xclip`으로 출력을

741+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K182[m[K[36m[K:[m[K[1;33m[Kbat[m[K main.cpp | xclip

742+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K184[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`는 출력이 우회되고 있다는 것을 감지하여 파일 내용 그대로를 출력합니다.

743+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K188[m[K[36m[K:[m[K`MANPAGER` 환경 변수 설정을 통해 `[1;33m[Kbat[m[K`을 `man`의 컬러 페이저(pager)로 쓸 수

744+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K192[m[K[36m[K:[m[Kexport MANPAGER="sh -c 'col -bx | [1;33m[Kbat[m[K -l man -p'"

745+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K195[m[K[36m[K:[m[K(Debian이나 Ubuntu를 사용한다면 `[1;33m[Kbat[m[K`을 `[1;33m[Kbat[m[Kcat`으로 치환하세요.)

746+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K200[m[K[36m[K:[m[K[`[1;33m[Kbat[m[Kman`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras/blob/master/doc/[1;33m[Kbat[m[Kman.md)을 쓸

747+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K207[m[K[36m[K:[m[K[작동하지 않습니다](https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/1145).

748+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K211[m[K[36m[K:[m[K[`pretty[1;33m[Kbat[m[K`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras/blob/master/doc/pretty[1;33m[Kbat[m[K.md)

749+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K212[m[K[36m[K:[m[K스크립트는 코드를 포맷하고 `[1;33m[Kbat[m[K`으로 출력하는 래퍼(wrapper)입니다.

750+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K217[m[K[36m[K:[m[K[![Packaging status](https://repology.org/badge/vertical-allrepos/[1;33m[Kbat[m[K-cat.svg)](https://repology.org/project/[1;33m[Kbat[m[K-cat/versions)

751+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K222[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`은 [Ubuntu](https://packages.ubuntu.com/eoan/[1;33m[Kbat[m[K)와

752+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K223[m[K[36m[K:[m[K[Debian](https://packages.debian.org/sid/[1;33m[Kbat[m[K) 패키지 배포 과정에 도입되는 중이며,

753+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K225[m[K[36m[K:[m[K현재 Debain에서는 불안정한 "Sid" 브랜치에서만 `[1;33m[Kbat[m[K`이 제공됩니다.

754+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K230[m[K[36m[K:[m[Kapt install [1;33m[Kbat[m[K

755+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K233[m[K[36m[K:[m[K**중요**: 만약 `[1;33m[Kbat[m[K`을 이와 같이 설치한다면, ([다른 패키지와의 이름

756+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K234[m[K[36m[K:[m[K충돌](https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/982)로 인하여) `[1;33m[Kbat[m[K` 대신에

757+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K235[m[K[36m[K:[m[K`[1;33m[Kbat[m[Kcat`이라는 이름의 실행 파일로 설치될 수 있음을 참고하세요.

758+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K236[m[K[36m[K:[m[K이에 따른 문제들과 다른 배포판들과의 일관성을 위하여 `[1;33m[Kbat[m[K -> [1;33m[Kbat[m[Kcat` symlink

759+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K240[m[K[36m[K:[m[Kln -s /usr/bin/[1;33m[Kbat[m[Kcat ~/.local/bin/[1;33m[Kbat[m[K

760+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K247[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`을 원한다면, [릴리즈 페이지](https://github.com/sharkdp/[1;33m[Kbat[m[K/releases)에서

761+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K251[m[K[36m[K:[m[Ksudo dpkg -i [1;33m[Kbat[m[K_0.18.3_amd64.deb # adapt version number and architecture

762+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K257[m[K[36m[K:[m[K[`[1;33m[Kbat[m[K` 패키지](https://pkgs.alpinelinux.org/packages?name=[1;33m[Kbat[m[K)를 설치할 수

763+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K261[m[K[36m[K:[m[Kapk add [1;33m[Kbat[m[K

764+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K267[m[K[36m[K:[m[K[`[1;33m[Kbat[m[K` 패키지](https://www.archlinux.org/packages/community/x86_64/[1;33m[Kbat[m[K/)를

765+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K271[m[K[36m[K:[m[Kpacman -S [1;33m[Kbat[m[K

766+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K279[m[K[36m[K:[m[K[`[1;33m[Kbat[m[K` 패키지](https://koji.fedoraproject.org/koji/packageinfo?packageID=27506)를

767+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K283[m[K[36m[K:[m[Kdnf install [1;33m[Kbat[m[K

768+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K288[m[K[36m[K:[m[Kdev-kit을 통해 [`[1;33m[Kbat[m[K` 패키지](https://github.com/funtoo/dev-kit/tree/1.4-release/sys-apps/[1;33m[Kbat[m[K)를 설치할 수 있습니다:

769+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K291[m[K[36m[K:[m[Kemerge sys-apps/[1;33m[Kbat[m[K

770+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K297[m[K[36m[K:[m[K[`[1;33m[Kbat[m[K` 패키지](https://packages.gentoo.org/packages/sys-apps/[1;33m[Kbat[m[K)를 설치할 수

771+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K301[m[K[36m[K:[m[Kemerge sys-apps/[1;33m[Kbat[m[K

772+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K306[m[K[36m[K:[m[Kxbps-install을 이용해 `[1;33m[Kbat[m[K`을 설치할 수 있습니다:

773+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K308[m[K[36m[K:[m[Kxbps-install -S [1;33m[Kbat[m[K

774+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K313[m[K[36m[K:[m[Kpkg를 이용해 `[1;33m[Kbat[m[K`을 설치할 수 있습니다:

775+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K315[m[K[36m[K:[m[Kpkg install [1;33m[Kbat[m[K

776+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K321[m[K[36m[K:[m[K[`[1;33m[Kbat[m[K` 패키지](https://www.freshports.org/textproc/[1;33m[Kbat[m[K)를 설치할 수 있습니다:

777+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K324[m[K[36m[K:[m[Kpkg install [1;33m[Kbat[m[K

778+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K330[m[K[36m[K:[m[Kcd /usr/ports/textproc/[1;33m[Kbat[m[K

779+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K336[m[K[36m[K:[m[K[nix package manager](https://nixos.org/nix)를 이용해 `[1;33m[Kbat[m[K`을 설치할 수

780+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K340[m[K[36m[K:[m[Knix-env -i [1;33m[Kbat[m[K

781+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K345[m[K[36m[K:[m[Kzypper를 이용해 `[1;33m[Kbat[m[K`을 설치할 수 있습니다:

782+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K348[m[K[36m[K:[m[Kzypper install [1;33m[Kbat[m[K

783+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K355[m[K[36m[K:[m[K[문제](https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/1519)가 있을 수 있습니다.

784+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K360[m[K[36m[K:[m[K[macOS의 Homebrew](https://formulae.brew.sh/formula/[1;33m[Kbat[m[K) 또는

785+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K361[m[K[36m[K:[m[K[Linux의 Homebrew](https://formulae.brew.sh/formula-linux/[1;33m[Kbat[m[K)를 이용하여

786+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K362[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`을 설치할 수 있습니다.

787+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K365[m[K[36m[K:[m[Kbrew install [1;33m[Kbat[m[K

788+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K370[m[K[36m[K:[m[K[MacPorts](https://ports.macports.org/port/[1;33m[Kbat[m[K/summary)를 이용하여 `[1;33m[Kbat[m[K`을

789+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K374[m[K[36m[K:[m[Kport install [1;33m[Kbat[m[K

790+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K379[m[K[36m[K:[m[KWindows에서 `[1;33m[Kbat[m[K`을 설치할 수 있는 몇 가지 옵션들이 있습니다.

791+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K380[m[K[36m[K:[m[K먼저 `[1;33m[Kbat[m[K`을 설치한 후,

792+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K381[m[K[36m[K:[m[K["Windows에서 `[1;33m[Kbat[m[K` 사용하기"](#windows에서-[1;33m[Kbat[m[K-사용하기) 섹션을 살펴보세요.

793+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K390[m[K[36m[K:[m[K[Chocolatey](https://chocolatey.org/packages/[1;33m[KBat[m[K)를 이용해 `[1;33m[Kbat[m[K`을 설치할 수

794+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K393[m[K[36m[K:[m[Kchoco install [1;33m[Kbat[m[K

795+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K398[m[K[36m[K:[m[K[scoop](https://scoop.sh/)을 이용해 `[1;33m[Kbat[m[K`을 설치할 수 있습니다:

796+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K400[m[K[36m[K:[m[Kscoop install [1;33m[Kbat[m[K

797+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K405[m[K[36m[K:[m[K[릴리즈 페이지](https://github.com/sharkdp/[1;33m[Kbat[m[K/releases)에서 사전 빌드된

798+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K413[m[K[36m[K:[m[K[릴리즈 페이지](https://github.com/sharkdp/[1;33m[Kbat[m[K/releases)에서 다양한 아키텍처를

799+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K419[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`의 소스를 빌드하기 위해서는, Rust 1.46 이상이 필요합니다.

800+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K423[m[K[36m[K:[m[Kcargo install --locked [1;33m[Kbat[m[K

801+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K435[m[K[36m[K:[m[K`[1;33m[Kbat[m[K --list-themes`을 사용하여 사용 가능한 문법 강조 테마들의 목록을 확인할 수

802+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K437[m[K[36m[K:[m[K`TwoDark` 테마를 선택하려면, `--theme=TwoDark` 옵션과 함께 `[1;33m[Kbat[m[K`을 사용하거나

803+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K438[m[K[36m[K:[m[K`[1;33m[KBAT[m[K_THEME` 환경 변수를 `TwoDark`로 설정하세요.

804+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K439[m[K[36m[K:[m[K셸 시작 파일에 `export [1;33m[KBAT[m[K_THEME="TwoDark"` 를 정의해 영구적으로 설정할 수

805+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K441[m[K[36m[K:[m[K이 밖에 `[1;33m[Kbat[m[K`의 [설정 파일](#설정-파일)을 이용할 수 있습니다.

806+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K447[m[K[36m[K:[m[K[1;33m[Kbat[m[K --list-themes | fzf --preview="[1;33m[Kbat[m[K --theme={} --color=always /path/to/file"

807+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K450[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`은 기본적으로 어두운 배경에 적합합니다.

808+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K458[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`은 트루컬러 지원이 되더라도 항상

809+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K478[m[K[36m[K:[m[K- 만약 터미널 테마를 바꾼다면, 이미 화면 상의 `[1;33m[Kbat[m[K`의 출력도 이에 맞추어

810+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K483[m[K[36m[K:[m[K`--style` 옵션을 이용하면 `[1;33m[Kbat[m[K`의 출력 모양을 조절할 수 있습니다.

811+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K486[m[K[36m[K:[m[K`[1;33m[KBAT[m[K_STYLE` 환경 변수를 정의하여 이러한 수정을 영구적으로 하거나 `[1;33m[Kbat[m[K`의

812+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K491[m[K[36m[K:[m[K만약 `[1;33m[Kbat[m[K`에서 특정 문법이 지원되지 않을 경우, 다음의 절차를 통해 현재 `[1;33m[Kbat[m[K`

813+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K494[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`은 문법 강조를 위해 훌륭한

814+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K506[m[K[36m[K:[m[K mkdir -p "$([1;33m[Kbat[m[K --config-dir)/syntaxes"

815+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K507[m[K[36m[K:[m[K cd "$([1;33m[Kbat[m[K --config-dir)/syntaxes"

816+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K517[m[K[36m[K:[m[K [1;33m[Kbat[m[K cache --build

817+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K520[m[K[36m[K:[m[K3. 마지막으로, `[1;33m[Kbat[m[K --list-languages`로 새로 추가한 언어가 사용 가능한지

818+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K526[m[K[36m[K:[m[K [1;33m[Kbat[m[K cache --clear

819+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K529[m[K[36m[K:[m[K4. 만약 특정 문법이 `[1;33m[Kbat[m[K`에 기본적으로 포함되어 있어야 한다고 생각한다면, 방침과

820+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K531[m[K[36m[K:[m[K 주세요: [문법 요청하기](https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/new?labels=syntax-request&template=syntax_request.md).

821+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K539[m[K[36m[K:[m[Kmkdir -p "$([1;33m[Kbat[m[K --config-dir)/themes"

822+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K540[m[K[36m[K:[m[Kcd "$([1;33m[Kbat[m[K --config-dir)/themes"

823+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K546[m[K[36m[K:[m[K[1;33m[Kbat[m[K cache --build

824+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K549[m[K[36m[K:[m[K마지막으로 `[1;33m[Kbat[m[K --list-themes`을 통해 새로 추가한 테마들이 사용 가능한지

825+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K559[m[K[36m[K:[m[K(`[1;33m[Kbat[m[K --list-languages`를 통해 개요를 확인하세요).

826+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K561[m[K[36m[K:[m[K참고: 이 옵션은 커맨드 라인에 넘겨 주는 것보다는 `[1;33m[Kbat[m[K`의 설정 파일에 넣는 것이

827+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K584[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`은 환경 변수 `PAGER`에 명시된 페이저를 사용합니다.

828+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K586[m[K[36m[K:[m[K만약 다른 페이저를 사용하고 싶다면, `PAGER` 변수를 수정하거나 `[1;33m[KBAT[m[K_PAGER` 환경

829+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K589[m[K[36m[K:[m[K만약 커맨드라인 인수들을 페이저에게 넘겨 주려면, `PAGER`/`[1;33m[KBAT[m[K_PAGER` 변수로

830+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K593[m[K[36m[K:[m[Kexport [1;33m[KBAT[m[K_PAGER="less -RF"

831+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K596[m[K[36m[K:[m[K환경 변수를 사용하는 대신, `[1;33m[Kbat[m[K`의 [설정 파일](#설정-파일)로 페이저를 설정할

832+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K600[m[K[36m[K:[m[K옵션이 지정되어 있지 않다면), `[1;33m[Kbat[m[K`은 다음 옵션들을 페이저로 넘겨줍니다:

833+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K619[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`은 페이저에 의존하지 않고 탭을 4 스페이스로 확장합니다.

834+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K623[m[K[36m[K:[m[K**참고**: (`[1;33m[Kbat[m[K`의 `--pager` 인자 혹은 `less`의 `LESS` 환경 변수를 통해)

835+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K627[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`을 `--tabs=0`과 함께 호출하면 이를 오버라이드하여 페이저가 탭을 처리하게

836+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K632[m[K[36m[K:[m[KmacOS에서 다크 모드를 사용하고 있다면, `[1;33m[Kbat[m[K`가 OS 테마에 따라 다른 테마를

837+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K638[m[K[36m[K:[m[Kalias cat="[1;33m[Kbat[m[K --theme=\$(defaults read -globalDomain AppleInterfaceStyle &> /dev/null && echo default || echo GitHub)"

838+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K643[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`는 설정 파일로도 사용자화 할 수 있습니다.

839+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K647[m[K[36m[K:[m[K[1;33m[Kbat[m[K --config-file

840+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K650[m[K[36m[K:[m[K또는, `[1;33m[KBAT[m[K_CONFIG_PATH` 환경 변수를 사용하여 `[1;33m[Kbat[m[K`가 설정 파일의 기본 경로

841+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K653[m[K[36m[K:[m[Kexport [1;33m[KBAT[m[K_CONFIG_PATH="/path/to/[1;33m[Kbat[m[K.conf"

842+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K658[m[K[36m[K:[m[K[1;33m[Kbat[m[K --generate-config-file

843+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K664[m[K[36m[K:[m[K`[1;33m[Kbat[m[K --help`로 가능한 모든 옵션과 값들을 확인하세요.

844+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K682[m[K[36m[K:[m[K## Windows에서 `[1;33m[Kbat[m[K` 사용하기

845+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K684[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`는 대부분의 경우 Windows에서 기본적으로 잘 작동하지만, 일부 기능은 추가적인

846+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K715[m[K[36m[K:[m[K`[1;33m[KBAT[m[K_PAGER`을 빈 문자열로 설정하여 페이징을 완전히 비활성화 할 수 있습니다.

847+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K719[m[K[36m[K:[m[KWindows에서의 `[1;33m[Kbat[m[K`은 기본적으로 Cygwin의 unix 스타일 경로(`/cygdrive/*`)를

848+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K721[m[K[36m[K:[m[KCygwin 절대 경로를 인자로 받았을 때, `[1;33m[Kbat[m[K`은 다음과 같은 오류를 반환합니다:

849+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K728[m[K[36m[K:[m[K[1;33m[Kbat[m[K() {

850+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K737[m[K[36m[K:[m[K command [1;33m[Kbat[m[K "${args[@]}"

851+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K745[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`은 터미널의 트루컬러 지원 여부와 상관 없이 동작합니다.

852+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K754[m[K[36m[K:[m[K그렇지 않을 경우, `[1;33m[Kbat[m[K`은 24비트 확장열(escape sequence)이 지원되는지 여부를

853+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K759[m[K[36m[K:[m[K다른 테마를 사용해 보세요 (`[1;33m[Kbat[m[K --list-themes`에서 목록을 볼 수 있습니다).

854+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K764[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`은 기본적으로 UTF-8과 UTF-16을 지원합니다.

855+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K770[m[K[36m[K:[m[Kiconv -f ISO-8859-1 -t UTF-8 my-file.php | [1;33m[Kbat[m[K

856+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K772[m[K[36m[K:[m[K참고: `[1;33m[Kbat[m[K`으로 문법 자동 감지가 되지 않는 경우에는 `-l`/`--language` 옵션을

857+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K779[m[K[36m[K:[m[Kgit clone --recursive https://github.com/sharkdp/[1;33m[Kbat[m[K

858+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K782[m[K[36m[K:[m[Kcd [1;33m[Kbat[m[K

859+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K791[m[K[36m[K:[m[K# 수정된 문법과 테마가 적용된 [1;33m[Kbat[m[K 바이너리 빌드

860+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K796[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`의 pretty-printing 기능을 라이브러리로 사용하는 애플리케이션을 만들고

861+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K797[m[K[36m[K:[m[K싶다면, [API 문서](https://docs.rs/[1;33m[Kbat[m[K/)를 살펴보세요.

862+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K798[m[K[36m[K:[m[K참고로 `[1;33m[Kbat[m[K`에 라이브러리로써 의존한다면, `regex-onig`나 `regex-fancy`를

863+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K814[m[K[36m[K:[m[K만약 `[1;33m[Kbat[m[K`의 취약점을 발견하였다면, [David Peter](https://david-peter.de/)에게 메일로 연락주시기 바랍니다.

864+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K818[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`은 다음과 같은 목표를 달성하려고 합니다:

866+[35m[Kdoc/README-ko.md[m[K[36m[K:[m[K[32m[K831[m[K[36m[K:[m[K`[1;33m[Kbat[m[K`는 여러분의 선택에 따라 MIT 라이센스 또는 Apache 라이센스 2.0의 조건에 따라

867+[35m[Kdoc/alternatives.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[KThe following table tries to give an overview *from `[1;33m[Kbat[m[K`s perspective*, i.e. we only compare

868+[35m[Kdoc/alternatives.md[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[Kcategories which are relevant for `[1;33m[Kbat[m[K`. Some of these projects have completely different goals and

869+[35m[Kdoc/alternatives.md[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[Kif you are not looking for a program like `[1;33m[Kbat[m[K`, this comparison might not be for you.

870+[35m[Kdoc/alternatives.md[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K| | [1;33m[Kbat[m[K | [pygments](http://pygments.org/) | [highlight](http://www.andre-simon.de/doku/highlight/highlight.php) | [ccat](https://github.com/jingweno/ccat) | [source-highlight](https://www.gnu.org/software/src-highlite/) | [hicat](https://github.com/rstacruz/hicat) | [coderay](https://github.com/rubychan/coderay) | [rouge](https://github.com/jneen/rouge) |

871+[35m[Kdoc/alternatives.md[m[K[36m[K:[m[K[32m[K9[m[K[36m[K:[m[K| Drop-in `cat` replacement | :heavy_check_mark: [*](https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/134) | :x: | :x: | (:heavy_check_mark:) | :x: | :x: [*](https://github.com/rstacruz/hicat/issues/6) | :x: | :x: |

872+[35m[Kdoc/alternatives.md[m[K[36m[K:[m[K[32m[K43[m[K[36m[K:[m[Kcmd_[1;33m[Kbat[m[K="[1;33m[Kbat[m[K --style=full --color=always --paging=never '$SRC'"

873+[35m[Kdoc/alternatives.md[m[K[36m[K:[m[K[32m[K44[m[K[36m[K:[m[Kcmd_[1;33m[Kbat[m[K_simple="[1;33m[Kbat[m[K --plain --wrap=never --tabs=0 --color=always --paging=never '$SRC'"

874+[35m[Kdoc/alternatives.md[m[K[36m[K:[m[K[32m[K54[m[K[36m[K:[m[K "$cmd_[1;33m[Kbat[m[K" \

875+[35m[Kdoc/alternatives.md[m[K[36m[K:[m[K[32m[K55[m[K[36m[K:[m[K "$cmd_[1;33m[Kbat[m[K_simple" \

876+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[K <img src="logo-header.svg" alt="[1;33m[Kbat[m[K - a cat clone with wings">

877+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K <a href="https://github.com/sharkdp/[1;33m[Kbat[m[K/actions?query=workflow%3ACICD"><img src="https://github.com/sharkdp/[1;33m[Kbat[m[K/workflows/CICD/badge.svg" alt="Build Status"></a>

878+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K <img src="https://img.shields.io/crates/l/[1;33m[Kbat[m[K.svg" alt="license">

879+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K <a href="https://crates.io/crates/[1;33m[Kbat[m[K"><img src="https://img.shields.io/crates/v/[1;33m[Kbat[m[K.svg?colorB=319e8c" alt="Version info"></a>

880+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[K [<a href="https://github.com/chinanf-boy/[1;33m[Kbat[m[K-zh">中文</a>]

881+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K24[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` поддерживает выделение синтаксиса для огромного количества языков программирования и разметки:

882+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K29[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` использует `git`, чтобы показать изменения в коде

883+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K42[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` умеет перенаправлять вывод в `less`, если вывод не помещается на экране полностью.

884+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K47[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` обнаружит неинтерактивный терминал (например, когда вы перенаправляете вывод в файл или процесс), он будет работать как утилита `cat` и выведет содержимое файлов как обычный текст (без подсветки синтаксиса).

885+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K54[m[K[36m[K:[m[K> [1;33m[Kbat[m[K README.md

886+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K60[m[K[36m[K:[m[K> [1;33m[Kbat[m[K src/*.rs

887+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K66[m[K[36m[K:[m[K> curl -s https://sh.rustup.rs | [1;33m[Kbat[m[K

888+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K72[m[K[36m[K:[m[K> yaml2json .travis.yml | json_pp | [1;33m[Kbat[m[K -l json

889+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K77[m[K[36m[K:[m[K> [1;33m[Kbat[m[K -A /etc/hosts

890+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K83[m[K[36m[K:[m[K[1;33m[Kbat[m[K > note.md # мгновенно создаем новый файл

891+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K85[m[K[36m[K:[m[K[1;33m[Kbat[m[K header.md content.md footer.md > document.md

892+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K87[m[K[36m[K:[m[K[1;33m[Kbat[m[K -n main.rs # показываем только количество строк

893+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K89[m[K[36m[K:[m[K[1;33m[Kbat[m[K f - g # выводит 'f' в stdin, а потом 'g'.

894+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K96[m[K[36m[K:[m[KВы можете использовать флаг `-exec` в `find`, чтобы посмотреть превью всех файлов в `[1;33m[Kbat[m[K`

895+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K98[m[K[36m[K:[m[Kfind … -exec [1;33m[Kbat[m[K {} +

896+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K101[m[K[36m[K:[m[KЕсли вы используете [`fd`](https://github.com/sharkdp/fd), применяйте для этого флаг `-X`/`--exec-[1;33m[Kbat[m[Kch`:

897+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K103[m[K[36m[K:[m[Kfd … -X [1;33m[Kbat[m[K

898+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K108[m[K[36m[K:[m[KС помощью [`[1;33m[Kbat[m[Kgrep`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras/blob/master/doc/[1;33m[Kbat[m[Kgrep.md), `[1;33m[Kbat[m[K` может быть использован для вывода результата запроса [`ripgrep`](https://github.com/BurntSushi/ripgrep)

899+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K111[m[K[36m[K:[m[K[1;33m[Kbat[m[Kgrep needle src/

900+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K116[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` может быть использован вместе с `tail -f`, чтобы выводить содержимое файла с подсветкой синтаксиса в реальном времени.

901+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K118[m[K[36m[K:[m[Ktail -f /var/log/pacman.log | [1;33m[Kbat[m[K --paging=never -l log

902+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K124[m[K[36m[K:[m[KВы можете использовать `[1;33m[Kbat[m[K` с `git show`, чтобы просмотреть старую версию файла с выделением синтаксиса:

903+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K126[m[K[36m[K:[m[Kgit show v0.6.0:src/main.rs | [1;33m[Kbat[m[K -l rs

904+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K136[m[K[36m[K:[m[K[1;33m[Kbat[m[K main.cpp | xclip

905+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K138[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` обнаружит перенаправление вывода и выведет обычный текст без выделения синтаксиса.

906+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K142[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` может быть использован в виде выделения цвета для `man`, для этого установите переменную окружения

907+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K146[m[K[36m[K:[m[Kexport MANPAGER="sh -c 'col -bx | [1;33m[Kbat[m[K -l man -p'"

908+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K152[m[K[36m[K:[m[KЕсли вы хотите сделать этой одной командой, вы можете использовать [`[1;33m[Kbat[m[Kman`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras/blob/master/doc/[1;33m[Kbat[m[Kman.md).

909+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K158[m[K[36m[K:[m[K[`Pretty[1;33m[Kbat[m[K`](https://github.com/eth-p/[1;33m[Kbat[m[K-extras/blob/master/doc/pretty[1;33m[Kbat[m[K.md) — скрипт, который форматирует код и выводит его с помощью `[1;33m[Kbat[m[K`.

910+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K163[m[K[36m[K:[m[K[![Packaging status](https://repology.org/badge/vertical-allrepos/[1;33m[Kbat[m[K.svg)](https://repology.org/project/[1;33m[Kbat[m[K/versions)

911+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K168[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` есть в репозиториях [Ubuntu](https://packages.ubuntu.com/eoan/[1;33m[Kbat[m[K) и

912+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K169[m[K[36m[K:[m[K[Debian](https://packages.debian.org/sid/[1;33m[Kbat[m[K) и доступен начиная с Ubuntu Eoan 19.10. На Debian `[1;33m[Kbat[m[K` пока что доступен только с нестабильной веткой "Sid".

913+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K171[m[K[36m[K:[m[KЕсли ваша версия Ubuntu/Debian достаточно новая, вы можете установить `[1;33m[Kbat[m[K` так:

914+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K174[m[K[36m[K:[m[Kapt install [1;33m[Kbat[m[K

915+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K177[m[K[36m[K:[m[KЕсли вы установили `[1;33m[Kbat[m[K` таким образом, то бинарный файл может быть установлен как `[1;33m[Kbat[m[Kcat` вместо `[1;33m[Kbat[m[K` (из-за [конфликта имени с другим пакетом](https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/982)). Вы можете сделать симлинк или алиас `[1;33m[Kbat[m[K -> [1;33m[Kbat[m[Kcat`, чтобы предотвратить подобные проблемы и в других дистрибутивах.

916+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K181[m[K[36m[K:[m[Kln -s /usr/bin/[1;33m[Kbat[m[Kcat ~/.local/bin/[1;33m[Kbat[m[K

917+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K187[m[K[36m[K:[m[KЕсли пакет еще недоступен в вашем Ubuntu/Debian дистрибутиве или вы хотите установить самую последнюю версию `[1;33m[Kbat[m[K`, то вы можете скачать самый последний `deb`-пакет отсюда:

918+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K188[m[K[36m[K:[m[K[release page](https://github.com/sharkdp/[1;33m[Kbat[m[K/releases) и установить так:

919+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K191[m[K[36m[K:[m[Ksudo dpkg -i [1;33m[Kbat[m[K_0.18.3_amd64.deb # измените архитектуру и версию

920+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K196[m[K[36m[K:[m[KВы можете установить [`[1;33m[Kbat[m[K`](https://pkgs.alpinelinux.org/packages?name=[1;33m[Kbat[m[K) из официальных источников:

921+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K199[m[K[36m[K:[m[Kapk add [1;33m[Kbat[m[K

922+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K204[m[K[36m[K:[m[KВы можете установить [`[1;33m[Kbat[m[K`](https://www.archlinux.org/packages/community/x86_64/[1;33m[Kbat[m[K/) из официального источника:

923+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K207[m[K[36m[K:[m[Kpacman -S [1;33m[Kbat[m[K

924+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K212[m[K[36m[K:[m[KВы можете установить [`[1;33m[Kbat[m[K`](https://koji.fedoraproject.org/koji/packageinfo?packageID=27506) из официального репозитория [Fedora Modular](https://docs.fedoraproject.org/en-US/modularity/using-modules/).

925+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K215[m[K[36m[K:[m[Kdnf install [1;33m[Kbat[m[K

926+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K220[m[K[36m[K:[m[KВы можете установить [`[1;33m[Kbat[m[K`](https://packages.gentoo.org/packages/sys-apps/[1;33m[Kbat[m[K) из официальных источников:

927+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K223[m[K[36m[K:[m[Kemerge sys-apps/[1;33m[Kbat[m[K

928+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K228[m[K[36m[K:[m[KВы можете установить `[1;33m[Kbat[m[K` с помощью `xbps-install`:

929+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K230[m[K[36m[K:[m[Kxbps-install -S [1;33m[Kbat[m[K

930+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K235[m[K[36m[K:[m[KВы можете установить [`[1;33m[Kbat[m[K`](https://www.freshports.org/textproc/[1;33m[Kbat[m[K) с помощью `pkg`:

931+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K238[m[K[36m[K:[m[Kpkg install [1;33m[Kbat[m[K

932+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K244[m[K[36m[K:[m[Kcd /usr/ports/textproc/[1;33m[Kbat[m[K

933+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K250[m[K[36m[K:[m[KВы можете установить `[1;33m[Kbat[m[K`, используя [nix package manager](https://nixos.org/nix):

934+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K253[m[K[36m[K:[m[Knix-env -i [1;33m[Kbat[m[K

935+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K258[m[K[36m[K:[m[KВы можете установить `[1;33m[Kbat[m[K` с помощью `zypper`:

936+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K261[m[K[36m[K:[m[Kzypper install [1;33m[Kbat[m[K

937+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K266[m[K[36m[K:[m[KВы можете установить `[1;33m[Kbat[m[K` с помощью [Homebrew](http://braumeister.org/formula/[1;33m[Kbat[m[K):

938+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K269[m[K[36m[K:[m[Kbrew install [1;33m[Kbat[m[K

939+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K272[m[K[36m[K:[m[KИли же установить его с помощью [MacPorts](https://ports.macports.org/port/[1;33m[Kbat[m[K/summary):

940+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K275[m[K[36m[K:[m[Kport install [1;33m[Kbat[m[K

941+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K280[m[K[36m[K:[m[KЕсть несколько способов установить `[1;33m[Kbat[m[K`. Как только вы установили его, посмотрите на секцию ["Использование `[1;33m[Kbat[m[K` в Windows"](#using-[1;33m[Kbat[m[K-on-windows).

942+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K284[m[K[36m[K:[m[KВы можете установить `[1;33m[Kbat[m[K` с помощью [Chocolatey](https://chocolatey.org/packages/[1;33m[KBat[m[K):

943+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K286[m[K[36m[K:[m[Kchoco install [1;33m[Kbat[m[K

944+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K291[m[K[36m[K:[m[KВы можете установить `[1;33m[Kbat[m[K` с помощью [scoop](https://scoop.sh/):

945+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K293[m[K[36m[K:[m[Kscoop install [1;33m[Kbat[m[K

946+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K300[m[K[36m[K:[m[KИх вы можете скачать на [странице релизов](https://github.com/sharkdp/[1;33m[Kbat[m[K/releases).

947+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K306[m[K[36m[K:[m[KВы можете использовать [Docker image](https://hub.docker.com/r/danlynn/[1;33m[Kbat[m[K/), чтобы запустить `[1;33m[Kbat[m[K` в контейнере:

948+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K308[m[K[36m[K:[m[Kdocker pull danlynn/[1;33m[Kbat[m[K

949+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K309[m[K[36m[K:[m[Kalias [1;33m[Kbat[m[K='docker run -it --rm -e [1;33m[KBAT[m[K_THEME -e [1;33m[KBAT[m[K_STYLE -e [1;33m[KBAT[m[K_TABS -v "$(pwd):/myapp" danlynn/[1;33m[Kbat[m[K'

950+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K314[m[K[36m[K:[m[KВы можете установить `[1;33m[Kbat[m[K` с [Ansible](https://www.ansible.com/):

951+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K318[m[K[36m[K:[m[Kansible-galaxy install aeimer.install_[1;33m[Kbat[m[K

952+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K323[m[K[36m[K:[m[K# Playbook для установки [1;33m[Kbat[m[K

953+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K326[m[K[36m[K:[m[K - aeimer.install_[1;33m[Kbat[m[K

954+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K329[m[K[36m[K:[m[K- [Ansible Galaxy](https://galaxy.ansible.com/aeimer/install_[1;33m[Kbat[m[K)

955+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K330[m[K[36m[K:[m[K- [GitHub](https://github.com/aeimer/ansible-install-[1;33m[Kbat[m[K)

956+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K342[m[K[36m[K:[m[KПерейдите на [страницу релизов](https://github.com/sharkdp/[1;33m[Kbat[m[K/releases) для

957+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K343[m[K[36m[K:[m[Kскомпилированных файлов `[1;33m[Kbat[m[K` для различных платформ. Бинарные файлы со статической связкой так же доступны: выбирайте архив с `musl` в имени.

958+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K347[m[K[36m[K:[m[KЕсли вы желаете установить `[1;33m[Kbat[m[K` из исходников, вам понадобится Rust 1.46 или выше. После этого используйте `cargo`, чтобы все скомпилировать:

959+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K350[m[K[36m[K:[m[Kcargo install --locked [1;33m[Kbat[m[K

960+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K357[m[K[36m[K:[m[KИспользуйте `[1;33m[Kbat[m[K --list-themes`, чтобы вывести список всех доступных тем. Для выбора темы `TwoDark` используйте `[1;33m[Kbat[m[K` с флагом

961+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K358[m[K[36m[K:[m[K`--theme=TwoDark` или выставьте переменную окружения `[1;33m[KBAT[m[K_THEME` в `TwoDark`. Используйте `export [1;33m[KBAT[m[K_THEME="TwoDark"` в конфигурационном файле вашей оболочки, чтобы изменить ее навсегда. Или же используйте [конфигурационный файл](https://github.com/sharkdp/[1;33m[Kbat[m[K#configuration-file) `[1;33m[Kbat[m[K`.

962+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K362[m[K[36m[K:[m[K[1;33m[Kbat[m[K --list-themes | fzf --preview="[1;33m[Kbat[m[K --theme={} --color=always /путь/к/файлу"

963+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K365[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` отлично смотрится на темном фоне. Однако если ваш терминал использует светлую тему, то такие темы как `GitHub` или `OneHalfLight` будут смотреться куда лучше!

964+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K366[m[K[36m[K:[m[KВы также можете использовать новую тему, для этого перейдите [в раздел добавления тем](https://github.com/sharkdp/[1;33m[Kbat[m[K#добавление-новых-тем).

965+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K370[m[K[36m[K:[m[KВы можете использовать флаг `--style`, чтобы изменять внешний вид вывода в `[1;33m[Kbat[m[K`.

966+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K371[m[K[36m[K:[m[KНапример, вы можете использовать `--style=numbers,changes`, чтобы показать только количество строк и изменений в Git. Установите переменную окружения `[1;33m[KBAT[m[K_STYLE` чтобы изменить это навсегда, или используйте [конфиг файл](https://github.com/sharkdp/[1;33m[Kbat[m[K#configuration-file) `[1;33m[Kbat[m[K`.

967+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K375[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` использует [`syntect`](https://github.com/trishume/syntect/) для выделения синтаксиса. `syntect` может читать

968+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K382[m[K[36m[K:[m[Kmkdir -p "$([1;33m[Kbat[m[K --config-dir)/syntaxes"

969+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K383[m[K[36m[K:[m[Kcd "$([1;33m[Kbat[m[K --config-dir)/syntaxes"

970+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K393[m[K[36m[K:[m[K[1;33m[Kbat[m[K cache --build

971+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K396[m[K[36m[K:[m[KТеперь вы можете использовать `[1;33m[Kbat[m[K --list-languages`, чтобы проверить, доступны ли новые языки.

972+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K401[m[K[36m[K:[m[K[1;33m[Kbat[m[K cache --clear

973+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K410[m[K[36m[K:[m[Kmkdir -p "$([1;33m[Kbat[m[K --config-dir)/themes"

974+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K411[m[K[36m[K:[m[Kcd "$([1;33m[Kbat[m[K --config-dir)/themes"

975+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K417[m[K[36m[K:[m[K[1;33m[Kbat[m[K cache --build

976+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K420[m[K[36m[K:[m[KТеперь используйте `[1;33m[Kbat[m[K --list-themes`, чтобы проверить доступность новых тем.

977+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K424[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` использует пейджер, указанный в переменной окружения `PAGER`. Если она не задана, то используется `less`.

978+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K425[m[K[36m[K:[m[KЕсли вы желаете использовать другой пейджер, вы можете либо изменить переменную `PAGER`, либо `[1;33m[KBAT[m[K_PAGER` чтобы перезаписать то, что указано в `PAGER`.

979+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K430[m[K[36m[K:[m[Kexport [1;33m[KBAT[m[K_PAGER="less -RF"

980+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K433[m[K[36m[K:[m[KТак же вы можете использовать [файл конфигурации](https://github.com/sharkdp/[1;33m[Kbat[m[K#configuration-file) `[1;33m[Kbat[m[K` (флаг `--pager`).

981+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K436[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` задаст следующие флаги для пейджера:

982+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K449[m[K[36m[K:[m[KЕсли вы используете темный режим в macOS, возможно вы захотите чтобы `[1;33m[Kbat[m[K` использовал другую тему, основанную на теме вашей ОС. Следующий сниппет использует тему `default`, когда у вас включен темный режим, и тему `GitHub`, когда включен светлый.

983+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K452[m[K[36m[K:[m[Kalias cat="[1;33m[Kbat[m[K --theme=\$(defaults read -globalDomain AppleInterfaceStyle &> /dev/null && echo default || echo GitHub)"

984+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K457[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` также может быть кастомизирован с помощью файла конфигурации. Его местоположение зависит от вашей ОС: чтобы посмотреть его путь, введите

985+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K459[m[K[36m[K:[m[K[1;33m[Kbat[m[K --config-file

986+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K462[m[K[36m[K:[m[KТакже вы можете установить переменную окружения `[1;33m[KBAT[m[K_CONFIG_PATH`, чтобы изменить путь к файлу конфигурации.

987+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K464[m[K[36m[K:[m[Kexport [1;33m[KBAT[m[K_CONFIG_PATH="/path/to/[1;33m[Kbat[m[K.conf"

988+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K469[m[K[36m[K:[m[K[1;33m[Kbat[m[K --generate-config-file

989+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K474[m[K[36m[K:[m[KФайл конфигурации - это всего лишь набор аргументов. Введите `[1;33m[Kbat[m[K --help`, чтобы просмотреть список всех возможных флагов и аргументов. Также вы можете закомментировать строку с помощью `#`.

990+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K494[m[K[36m[K:[m[K## Использование `[1;33m[Kbat[m[K` в Windows

991+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K496[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` полностью работоспособен "из коробки", но для некоторых возможностей могут понадобиться дополнительные настройки.

992+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K509[m[K[36m[K:[m[Kили установить `[1;33m[KBAT[m[K_PAGER` равным пустой строке.

993+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K513[m[K[36m[K:[m[KИз коробки `[1;33m[Kbat[m[K` не поддерживает пути в стиле Unix (`/cygdrive/*`). Когда указан абсолютный путь cygwin, `[1;33m[Kbat[m[K` выдаст следующую ошибку: `The system cannot find the path specified. (os error 3)`

994+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K518[m[K[36m[K:[m[K[1;33m[Kbat[m[K() {

995+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K527[m[K[36m[K:[m[K command [1;33m[Kbat[m[K "${args[@]}"

996+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K535[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` поддерживает терминалы *с* и *без* поддержки truecolor. Однако подсветка синтаксиса не оптимизирована для терминалов с 8-битными цветами, и рекомендуется использовать терминалы с поддержкой 24-битных цветов (`terminator`, `konsole`, `iTerm2`, ...).

997+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K539[m[K[36m[K:[m[K`24bit`. Иначе `[1;33m[Kbat[m[K` не сможет определить поддержку 24-битных цветов (и будет использовать 8-битные).

998+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K543[m[K[36m[K:[m[KИспользуйте другую тему (`[1;33m[Kbat[m[K --list-themes` выведет список всех установленных тем). Темы `OneHalfDark` и

999+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K548[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` поддерживает UTF-8 и UTF-16. Файлы в других кодировках, возможно, придётся перекодировать, так как кодировка может быть распознана неверно. Используйте `iconv`.

1000+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K551[m[K[36m[K:[m[Kiconv -f ISO-8859-1 -t UTF-8 my-file.php | [1;33m[Kbat[m[K

1001+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K553[m[K[36m[K:[m[KВнимание: вам может понадобится флаг `-l`/`--language`, если `[1;33m[Kbat[m[K` не сможет автоматически определить синтаксис.

1002+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K559[m[K[36m[K:[m[Kgit clone --recursive https://github.com/sharkdp/[1;33m[Kbat[m[K

1003+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K562[m[K[36m[K:[m[Kcd [1;33m[Kbat[m[K

1004+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K571[m[K[36m[K:[m[K# Компилирование исполняего файла [1;33m[Kbat[m[K с другим синтаксисом и темами

1005+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K583[m[K[36m[K:[m[KЦели проекта `[1;33m[Kbat[m[K`:

1006+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K590[m[K[36m[K:[m[KЕсть очень много альтернатив `[1;33m[Kbat[m[K`. Смотрите [этот документ](doc/alternatives.md) для сравнения.

1008+[35m[Kdoc/README-ru.md[m[K[36m[K:[m[K[32m[K595[m[K[36m[K:[m[K`[1;33m[Kbat[m[K` распостраняется под лицензями MIT License и Apache License 2.0 (на выбор пользователя).

1009+[35m[Kdoc/release-checklist.md[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[KSee this page for a good overview: https://deps.rs/repo/github/sharkdp/[1;33m[Kbat[m[K

1010+[35m[Kdoc/release-checklist.md[m[K[36m[K:[m[K[32m[K27[m[K[36m[K:[m[K sure that it is available on the `PATH` (`[1;33m[Kbat[m[K --version` should show the

1011+[35m[Kdoc/release-checklist.md[m[K[36m[K:[m[K[32m[K41[m[K[36m[K:[m[K this, install the latest `[1;33m[Kbat[m[K` version again (to include the new synaxes

1012+[35m[Kdoc/release-checklist.md[m[K[36m[K:[m[K[32m[K50[m[K[36m[K:[m[K- [ ] Go to https://github.com/sharkdp/[1;33m[Kbat[m[K/releases/new to create the new

1013+[35m[KCargo.lock[m[K[36m[K:[m[K[32m[K85[m[K[36m[K:[m[Kname = "[1;33m[Kbat[m[K"

1015+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K# Coldark - [1;33m[KBat[m[K

1016+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K![GitHub License](https://img.shields.io/github/license/ArmandPhilippot/coldark-[1;33m[Kbat[m[K?colorA=111b27&color=d0dae7&logo=Github&logoColor=e3eaf2&style=for-the-badge) ![GitHub package.json version](https://img.shields.io/github/package-json/v/ArmandPhilippot/coldark-[1;33m[Kbat[m[K?colorA=111b27&color=d0dae7&logo=Github&logoColor=e3eaf2&style=for-the-badge)

1017+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K15[m[K[36m[K:[m[KThis Coldark version is designed for [[1;33m[Kbat[m[K](https://github.com/sharkdp/[1;33m[Kbat[m[K) command.

1018+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[KThe `[1;33m[Kbat[m[K` version uses almost the same colors as [VS code version](https://github.com/ArmandPhilippot/coldark-vscode). The scopes seems a little different and a little less complete, hence the difference.

1019+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K69[m[K[36m[K:[m[K1. Install `[1;33m[Kbat[m[K` (on Manjaro: `pacman -S [1;33m[Kbat[m[K`)

1020+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K70[m[K[36m[K:[m[K2. Create themes folder: `mkdir -p "$([1;33m[Kbat[m[K --config-dir)/themes"`

1021+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K71[m[K[36m[K:[m[K3. Go inside this new folder: `cd "$([1;33m[Kbat[m[K --config-dir)/themes"`

1022+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K72[m[K[36m[K:[m[K4. Clone this repo: `git clone https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K`

1023+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K73[m[K[36m[K:[m[K5. Update the binary cache: `[1;33m[Kbat[m[K cache --build`

1024+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K75[m[K[36m[K:[m[KThen, if you use `[1;33m[Kbat[m[K --list-themes`, you should see the themes.

1025+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K77[m[K[36m[K:[m[KColdark [1;33m[KBat[m[K is now present in [[1;33m[Kbat[m[K repo](https://github.com/sharkdp/[1;33m[Kbat[m[K). It may be present in the list of themes in a future version without having to install it manually.

1026+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K81[m[K[36m[K:[m[KTo select one of the Coldark themes, call `[1;33m[Kbat[m[K` with the `--theme=Coldark-Cold` (or `--theme=Coldark-Dark`) option or set the `[1;33m[KBAT[m[K_THEME` environment variable to `Coldark-Cold` (or `Coldark-Dark`). Use `export [1;33m[KBAT[m[K_THEME="Coldark-Cold"` (or `export [1;33m[KBAT[m[K_THEME="Coldark-Dark"`) in your shell's startup file to make the change permanent.

1027+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K91[m[K[36m[K:[m[K| [![Coldark Cold PHP](./assets/coldark-cold-[1;33m[Kbat[m[K-php.jpg)](./assets/coldark-cold-[1;33m[Kbat[m[K-php.jpg) | [![Coldark Cold Markdown](./assets/coldark-cold-[1;33m[Kbat[m[K-markdown.jpg)](./assets/coldark-cold-[1;33m[Kbat[m[K-markdown.jpg) |

1028+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K97[m[K[36m[K:[m[K| [![Coldark Dark PHP](./assets/coldark-dark-[1;33m[Kbat[m[K-php.jpg)](./assets/coldark-dark-[1;33m[Kbat[m[K-php.jpg) | [![Coldark Dark Markdown](./assets/coldark-dark-[1;33m[Kbat[m[K-markdown.jpg)](./assets/coldark-dark-[1;33m[Kbat[m[K-markdown.jpg) |

1029+[35m[Kassets/themes/Coldark/README.md[m[K[36m[K:[m[K[32m[K101[m[K[36m[K:[m[KThis project is open source and available under the [MIT License](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/blob/master/LICENSE).

1030+[35m[Kassets/themes/Coldark/Coldark-Cold.tmTheme[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K Project: Coldark [1;33m[KBat[m[K

1031+[35m[Kassets/themes/Coldark/Coldark-Cold.tmTheme[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K Repository: https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K

1032+[35m[Kassets/themes/Coldark/package.json[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[K "name": "coldark-[1;33m[Kbat[m[K",

1033+[35m[Kassets/themes/Coldark/package.json[m[K[36m[K:[m[K[32m[K15[m[K[36m[K:[m[K "homepage": "https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K#readme",

1034+[35m[Kassets/themes/Coldark/package.json[m[K[36m[K:[m[K[32m[K18[m[K[36m[K:[m[K "url": "https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K"

1035+[35m[Kassets/themes/Coldark/package.json[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[K "url": "https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/issues"

1036+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K10[m[K[36m[K:[m[K## [v1.0.5](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/compare/v1.0.4...v1.0.5)

1037+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K19[m[K[36m[K:[m[K- fix: change red color for both versions [`93ee1f3`](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/commit/93ee1f3fb5e08ecf66baee03dd3900c0abcdc1e9)

1038+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[K## [v1.0.4](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/compare/v1.0.3...v1.0.4) - 2020-10-28

1039+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K25[m[K[36m[K:[m[K- Update Coldark Colors / Complete Markdown syntax highlighting [`a355b1d`](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/commit/a355b1d75611d12d322dd47f2ea7799b663a7738)

1040+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K26[m[K[36m[K:[m[K- Update colors, logo, banner & add some screenshots [`0b13521`](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/commit/0b13521b6018c04d00304121bcf47fe04fa266ee)

1041+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K27[m[K[36m[K:[m[K- build: update auto-changelog command [`2cd0f6e`](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/commit/2cd0f6ea22280c892b564348aab72a45f7b28223)

1042+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K29[m[K[36m[K:[m[K## [v1.0.3](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/compare/v1.0.2...v1.0.3) - 2020-10-19

1043+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K33[m[K[36m[K:[m[K- fix: color for pseudo-class/element in CSS [`1fada34`](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/commit/1fada3494ae545fd186b1cb6c7d98c5860bcbcfe)

1044+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K35[m[K[36m[K:[m[K## [v1.0.2](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/compare/v1.0.1...v1.0.2) - 2020-10-18

1045+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K39[m[K[36m[K:[m[K- fix: update scopes to be up to date with VS Code theme [`e92f6a7`](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/commit/e92f6a7d7832d269cdec0754a198a589a4567a00)

1046+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K41[m[K[36m[K:[m[K## [v1.0.1](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/compare/v1.0.0...v1.0.1) - 2020-10-17

1047+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K45[m[K[36m[K:[m[K- docs: fix export command [`0439c73`](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/commit/0439c73d4af9c6a3254467dc7c6a758796f78267)

1048+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K51[m[K[36m[K:[m[K- feat: Coldark for [1;33m[Kbat[m[K command [`18fa11d`](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/commit/18fa11d259bd4c1b5d3278b1ef91dbf8a13e5ee1)

1049+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K52[m[K[36m[K:[m[K- Initial commit [`80b7c34`](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/commit/80b7c34079e11ae69fdd94d5839305fedd9fe847)

1050+[35m[Kassets/themes/Coldark/CHANGELOG.md[m[K[36m[K:[m[K[32m[K53[m[K[36m[K:[m[K- docs: add README [`e904c4d`](https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K/commit/e904c4d78e3ff7653b25a6215441ad643408aedf)

1051+[35m[Kassets/themes/Coldark/Coldark-Dark.tmTheme[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K Project: Coldark [1;33m[KBat[m[K

1052+[35m[Kassets/themes/Coldark/Coldark-Dark.tmTheme[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K Repository: https://github.com/ArmandPhilippot/coldark-[1;33m[Kbat[m[K

1053+[35m[Kassets/themes/Solarized/samples/test.md[m[K[36m[K:[m[K[32m[K26[m[K[36m[K:[m[K a ver[1;33m[Kbat[m[Kim or "code" block

1054+[35m[Kassets/themes/onehalf/README.md[m[K[36m[K:[m[K[32m[K43[m[K[36m[K:[m[K - [x] [[1;33m[Kbat[m[K](https://github.com/sharkdp/[1;33m[Kbat[m[K)

1055+[35m[Kassets/themes/base16.tmTheme[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[K the [1;33m[Kbat[m[K theme base16-256 instead.

1056+[35m[Kassets/themes/ansi.tmTheme[m[K[36m[K:[m[K[32m[K26[m[K[36m[K:[m[K Explicitly set the gutter color since [1;33m[Kbat[m[K falls back to a

1057+[35m[Kassets/themes/DarkNeon/Mou/Dark Neon Eighties.txt[m[K[36m[K:[m[K[32m[K77[m[K[36m[K:[m[KVER[1;33m[KBAT[m[KIM

1058+[35m[Kassets/themes/DarkNeon/Mou/Dark Neon.txt[m[K[36m[K:[m[K[32m[K77[m[K[36m[K:[m[KVER[1;33m[KBAT[m[KIM

1059+[35m[Kassets/themes/DarkNeon/Mou/Dark Neon Light.txt[m[K[36m[K:[m[K[32m[K77[m[K[36m[K:[m[KVER[1;33m[KBAT[m[KIM

1060+[35m[Kassets/themes/TwoDark/icons/Prefs/icon_script.tmPreferences[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K <string>source.dos[1;33m[Kbat[m[Kch, source.shell</string>

1061+[35m[Kassets/themes/TwoDark/src/svg/gfx_quick-panel-row-selected.svg[m[K[36m[K:[m[K[32m[K60[m[K[36m[K:[m[KpQxTwpjGF[1;33m[KbAt[m[Ki4KEppoxavUgB0Kt5geqNtU3yigwdL9zPN5DHw0QItval6DB1kZEzQTiJdJEmU3x

1062+[35m[Kassets/themes/gruvbox/README.md[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[KThis branch is being used as a submodule in [[1;33m[Kbat[m[K](https://github.com/sharkdp/[1;33m[Kbat[m[K) for the _gruvbox_ family of themes

1063+[35m[Kassets/themes/gruvbox/gruvbox-dark.tmTheme[m[K[36m[K:[m[K[32m[K259[m[K[36m[K:[m[K <string>entity.name.val.declaration, entity.name.variable, meta.definition.variable, storage.type.variable, support.type.custom-property, support.type.variable-name, variable, variable.interpolation variable, variable.other.interpolation variable, variable.parameter.dos[1;33m[Kbat[m[Kch, variable.parameter.output.function.matlab, variable.parameter.sass</string>

1064+[35m[Kassets/themes/gruvbox/gruvbox-light.tmTheme[m[K[36m[K:[m[K[32m[K259[m[K[36m[K:[m[K <string>entity.name.val.declaration, entity.name.variable, meta.definition.variable, storage.type.variable, support.type.custom-property, support.type.variable-name, variable, variable.interpolation variable, variable.other.interpolation variable, variable.parameter.dos[1;33m[Kbat[m[Kch, variable.parameter.output.function.matlab, variable.parameter.sass</string>

1065+[35m[Kassets/syntaxes/02_Extra/Slim/Demo/demo.slim[m[K[36m[K:[m[K[32m[K152[m[K[36m[K:[m[K/ Ver[1;33m[Kbat[m[Kim

1066+[35m[Kassets/syntaxes/02_Extra/Slim/Demo/demo.slim[m[K[36m[K:[m[K[32m[K163[m[K[36m[K:[m[K 'Ver[1;33m[Kbat[m[Kim text with space after

1067+[35m[Kassets/syntaxes/02_Extra/Slim/Syntaxes/Ruby Slim.YAML-tmLanguage[m[K[36m[K:[m[K[32m[K130[m[K[36m[K:[m[K comment: Ver[1;33m[Kbat[m[Kim text (can include HTML tags and copied lines)

1068+[35m[Kassets/syntaxes/02_Extra/Slim/Syntaxes/Ruby Slim.tmLanguage[m[K[36m[K:[m[K[32m[K326[m[K[36m[K:[m[K <string>Ver[1;33m[Kbat[m[Kim text (can include HTML tags and copied lines)</string>

1069+[35m[Kassets/syntaxes/02_Extra/LLVM/README.md[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[KLLVM syntax highlighting definitions based on [LLVM.tmBundle](https://github.com/whitequark/LLVM.tmBundle) created by [whitequark](https://github.com/whitequark) for [[1;33m[Kbat[m[K](https://github.com/sharkdp/[1;33m[Kbat[m[K).

1070+[35m[Kassets/syntaxes/02_Extra/Puppet/Puppet.sublime-build[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[K "cmd": ["puppet.[1;33m[Kbat[m[K", "parser", "validate", "--color=false", "$file" ]

1071+[35m[Kassets/syntaxes/02_Extra/Slim.sublime-syntax[m[K[36m[K:[m[K[32m[K117[m[K[36m[K:[m[K comment: Ver[1;33m[Kbat[m[Kim text (can include HTML tags and copied lines)

1072+[35m[Kassets/syntaxes/02_Extra/Assembly (x86_64).sublime-syntax[m[K[36m[K:[m[K[32m[K463[m[K[36m[K:[m[K - match: '(?i)\[1;33m[Kbat[m[K\b'

1073+[35m[Kassets/syntaxes/02_Extra/HTML (Twig).sublime-syntax[m[K[36m[K:[m[K[32m[K377[m[K[36m[K:[m[K - match: '(?<=(?:[a-zA-Z0-9_\x{7f}-\x{ff}\]\)\''\"]\|)|\{%\sfilter\s)([1;33m[Kbat[m[Kch|convert_encoding|date|date_modify|default|e(?:scape)?|format|join|merge|number_format|replace|round|slice|split|trim)(\()'

1076+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typingsInstaller.js[m[K[36m[K:[m[K[32m[K3584[m[K[36m[K:[m[K // The advantage of this approach is its simplicity. For the case of [1;33m[Kbat[m[Kch compilation,

1077+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typingsInstaller.js[m[K[36m[K:[m[K[32m[K37221[m[K[36m[K:[m[K // Literal files are always included ver[1;33m[Kbat[m[Kim. An "include" or "exclude" specification cannot

1078+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typingsInstaller.js[m[K[36m[K:[m[K[32m[K48035[m[K[36m[K:[m[K var ver[1;33m[Kbat[m[KimTargetName = ts.unescapeLeadingUnderscores(target.escapedName);

1079+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typingsInstaller.js[m[K[36m[K:[m[K[32m[K48036[m[K[36m[K:[m[K if (ver[1;33m[Kbat[m[KimTargetName === "export=" /* ExportEquals */ && (compilerOptions.esModuleInterop || compilerOptions.allowSyntheticDefaultImports)) {

1080+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typingsInstaller.js[m[K[36m[K:[m[K[32m[K48038[m[K[36m[K:[m[K ver[1;33m[Kbat[m[KimTargetName = "default" /* Default */;

1081+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typingsInstaller.js[m[K[36m[K:[m[K[32m[K48040[m[K[36m[K:[m[K var targetName = getInternalSymbolName(target, ver[1;33m[Kbat[m[KimTargetName);

1082+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typingsInstaller.js[m[K[36m[K:[m[K[32m[K48085[m[K[36m[K:[m[K ts.factory.createImportSpecifier(localName !== ver[1;33m[Kbat[m[KimTargetName ? ts.factory.createIdentifier(ver[1;33m[Kbat[m[KimTargetName) : undefined, ts.factory.createIdentifier(localName))

1083+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typingsInstaller.js[m[K[36m[K:[m[K[32m[K48094[m[K[36m[K:[m[K serializeExportSpecifier(ts.unescapeLeadingUnderscores(symbol.escapedName), specifier ? ver[1;33m[Kbat[m[KimTargetName : targetName, specifier && ts.isStringLiteralLike(specifier) ? ts.factory.createStringLiteral(specifier.text) : undefined);

1084+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typingsInstaller.js[m[K[36m[K:[m[K[32m[K98916[m[K[36m[K:[m[K // If he number will be printed ver[1;33m[Kbat[m[Kim and it doesn't already contain a dot, add one

1085+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typingsInstaller.js[m[K[36m[K:[m[K[32m[K101096[m[K[36m[K:[m[K * If `optimistic` is set, the first instance will use 'baseName' ver[1;33m[Kbat[m[Kim instead of 'baseName_1'

1086+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typingsInstaller.js[m[K[36m[K:[m[K[32m[K105964[m[K[36m[K:[m[K // Get next [1;33m[Kbat[m[Kch of affected files

1087+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typingsInstaller.js[m[K[36m[K:[m[K[32m[K108618[m[K[36m[K:[m[K // Upon detecting a file change, wait for 250ms and then perform a recompilation. This gives [1;33m[Kbat[m[Kch

1088+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsc.js[m[K[36m[K:[m[K[32m[K39425[m[K[36m[K:[m[K var ver[1;33m[Kbat[m[KimTargetName = ts.unescapeLeadingUnderscores(target.escapedName);

1089+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsc.js[m[K[36m[K:[m[K[32m[K39426[m[K[36m[K:[m[K if (ver[1;33m[Kbat[m[KimTargetName === "export=" && (compilerOptions.esModuleInterop || compilerOptions.allowSyntheticDefaultImports)) {

1090+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsc.js[m[K[36m[K:[m[K[32m[K39427[m[K[36m[K:[m[K ver[1;33m[Kbat[m[KimTargetName = "default";

1091+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsc.js[m[K[36m[K:[m[K[32m[K39429[m[K[36m[K:[m[K var targetName = getInternalSymbolName(target, ver[1;33m[Kbat[m[KimTargetName);

1092+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsc.js[m[K[36m[K:[m[K[32m[K39452[m[K[36m[K:[m[K ts.factory.createImportSpecifier(localName !== ver[1;33m[Kbat[m[KimTargetName ? ts.factory.createIdentifier(ver[1;33m[Kbat[m[KimTargetName) : undefined, ts.factory.createIdentifier(localName))

1093+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsc.js[m[K[36m[K:[m[K[32m[K39457[m[K[36m[K:[m[K serializeExportSpecifier(ts.unescapeLeadingUnderscores(symbol.escapedName), specifier ? ver[1;33m[Kbat[m[KimTargetName : targetName, specifier && ts.isStringLiteralLike(specifier) ? ts.factory.createStringLiteral(specifier.text) : undefined);

1094+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserver.js[m[K[36m[K:[m[K[32m[K3595[m[K[36m[K:[m[K // The advantage of this approach is its simplicity. For the case of [1;33m[Kbat[m[Kch compilation,

1095+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserver.js[m[K[36m[K:[m[K[32m[K37232[m[K[36m[K:[m[K // Literal files are always included ver[1;33m[Kbat[m[Kim. An "include" or "exclude" specification cannot

1096+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserver.js[m[K[36m[K:[m[K[32m[K48046[m[K[36m[K:[m[K var ver[1;33m[Kbat[m[KimTargetName = ts.unescapeLeadingUnderscores(target.escapedName);

1097+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserver.js[m[K[36m[K:[m[K[32m[K48047[m[K[36m[K:[m[K if (ver[1;33m[Kbat[m[KimTargetName === "export=" /* ExportEquals */ && (compilerOptions.esModuleInterop || compilerOptions.allowSyntheticDefaultImports)) {

1098+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserver.js[m[K[36m[K:[m[K[32m[K48049[m[K[36m[K:[m[K ver[1;33m[Kbat[m[KimTargetName = "default" /* Default */;

1099+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserver.js[m[K[36m[K:[m[K[32m[K48051[m[K[36m[K:[m[K var targetName = getInternalSymbolName(target, ver[1;33m[Kbat[m[KimTargetName);

1100+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserver.js[m[K[36m[K:[m[K[32m[K48096[m[K[36m[K:[m[K ts.factory.createImportSpecifier(localName !== ver[1;33m[Kbat[m[KimTargetName ? ts.factory.createIdentifier(ver[1;33m[Kbat[m[KimTargetName) : undefined, ts.factory.createIdentifier(localName))

1101+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserver.js[m[K[36m[K:[m[K[32m[K48105[m[K[36m[K:[m[K serializeExportSpecifier(ts.unescapeLeadingUnderscores(symbol.escapedName), specifier ? ver[1;33m[Kbat[m[KimTargetName : targetName, specifier && ts.isStringLiteralLike(specifier) ? ts.factory.createStringLiteral(specifier.text) : undefined);

1102+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserver.js[m[K[36m[K:[m[K[32m[K98927[m[K[36m[K:[m[K // If he number will be printed ver[1;33m[Kbat[m[Kim and it doesn't already contain a dot, add one

1103+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserver.js[m[K[36m[K:[m[K[32m[K101107[m[K[36m[K:[m[K * If `optimistic` is set, the first instance will use 'baseName' ver[1;33m[Kbat[m[Kim instead of 'baseName_1'

1104+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserver.js[m[K[36m[K:[m[K[32m[K105975[m[K[36m[K:[m[K // Get next [1;33m[Kbat[m[Kch of affected files

1105+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserver.js[m[K[36m[K:[m[K[32m[K108629[m[K[36m[K:[m[K // Upon detecting a file change, wait for 250ms and then perform a recompilation. This gives [1;33m[Kbat[m[Kch

1106+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescriptServices.js[m[K[36m[K:[m[K[32m[K3789[m[K[36m[K:[m[K // The advantage of this approach is its simplicity. For the case of [1;33m[Kbat[m[Kch compilation,

1107+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescriptServices.js[m[K[36m[K:[m[K[32m[K37426[m[K[36m[K:[m[K // Literal files are always included ver[1;33m[Kbat[m[Kim. An "include" or "exclude" specification cannot

1108+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescriptServices.js[m[K[36m[K:[m[K[32m[K48240[m[K[36m[K:[m[K var ver[1;33m[Kbat[m[KimTargetName = ts.unescapeLeadingUnderscores(target.escapedName);

1109+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescriptServices.js[m[K[36m[K:[m[K[32m[K48241[m[K[36m[K:[m[K if (ver[1;33m[Kbat[m[KimTargetName === "export=" /* ExportEquals */ && (compilerOptions.esModuleInterop || compilerOptions.allowSyntheticDefaultImports)) {

1110+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescriptServices.js[m[K[36m[K:[m[K[32m[K48243[m[K[36m[K:[m[K ver[1;33m[Kbat[m[KimTargetName = "default" /* Default */;

1111+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescriptServices.js[m[K[36m[K:[m[K[32m[K48245[m[K[36m[K:[m[K var targetName = getInternalSymbolName(target, ver[1;33m[Kbat[m[KimTargetName);

1112+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescriptServices.js[m[K[36m[K:[m[K[32m[K48290[m[K[36m[K:[m[K ts.factory.createImportSpecifier(localName !== ver[1;33m[Kbat[m[KimTargetName ? ts.factory.createIdentifier(ver[1;33m[Kbat[m[KimTargetName) : undefined, ts.factory.createIdentifier(localName))

1113+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescriptServices.js[m[K[36m[K:[m[K[32m[K48299[m[K[36m[K:[m[K serializeExportSpecifier(ts.unescapeLeadingUnderscores(symbol.escapedName), specifier ? ver[1;33m[Kbat[m[KimTargetName : targetName, specifier && ts.isStringLiteralLike(specifier) ? ts.factory.createStringLiteral(specifier.text) : undefined);

1114+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescriptServices.js[m[K[36m[K:[m[K[32m[K99121[m[K[36m[K:[m[K // If he number will be printed ver[1;33m[Kbat[m[Kim and it doesn't already contain a dot, add one

1115+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescriptServices.js[m[K[36m[K:[m[K[32m[K101301[m[K[36m[K:[m[K * If `optimistic` is set, the first instance will use 'baseName' ver[1;33m[Kbat[m[Kim instead of 'baseName_1'

1116+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescriptServices.js[m[K[36m[K:[m[K[32m[K106169[m[K[36m[K:[m[K // Get next [1;33m[Kbat[m[Kch of affected files

1117+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescriptServices.js[m[K[36m[K:[m[K[32m[K108823[m[K[36m[K:[m[K // Upon detecting a file change, wait for 250ms and then perform a recompilation. This gives [1;33m[Kbat[m[Kch

1118+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserverlibrary.js[m[K[36m[K:[m[K[32m[K3789[m[K[36m[K:[m[K // The advantage of this approach is its simplicity. For the case of [1;33m[Kbat[m[Kch compilation,

1119+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserverlibrary.js[m[K[36m[K:[m[K[32m[K37426[m[K[36m[K:[m[K // Literal files are always included ver[1;33m[Kbat[m[Kim. An "include" or "exclude" specification cannot

1120+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserverlibrary.js[m[K[36m[K:[m[K[32m[K48240[m[K[36m[K:[m[K var ver[1;33m[Kbat[m[KimTargetName = ts.unescapeLeadingUnderscores(target.escapedName);

1121+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserverlibrary.js[m[K[36m[K:[m[K[32m[K48241[m[K[36m[K:[m[K if (ver[1;33m[Kbat[m[KimTargetName === "export=" /* ExportEquals */ && (compilerOptions.esModuleInterop || compilerOptions.allowSyntheticDefaultImports)) {

1122+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserverlibrary.js[m[K[36m[K:[m[K[32m[K48243[m[K[36m[K:[m[K ver[1;33m[Kbat[m[KimTargetName = "default" /* Default */;

1123+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserverlibrary.js[m[K[36m[K:[m[K[32m[K48245[m[K[36m[K:[m[K var targetName = getInternalSymbolName(target, ver[1;33m[Kbat[m[KimTargetName);

1124+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserverlibrary.js[m[K[36m[K:[m[K[32m[K48290[m[K[36m[K:[m[K ts.factory.createImportSpecifier(localName !== ver[1;33m[Kbat[m[KimTargetName ? ts.factory.createIdentifier(ver[1;33m[Kbat[m[KimTargetName) : undefined, ts.factory.createIdentifier(localName))

1125+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserverlibrary.js[m[K[36m[K:[m[K[32m[K48299[m[K[36m[K:[m[K serializeExportSpecifier(ts.unescapeLeadingUnderscores(symbol.escapedName), specifier ? ver[1;33m[Kbat[m[KimTargetName : targetName, specifier && ts.isStringLiteralLike(specifier) ? ts.factory.createStringLiteral(specifier.text) : undefined);

1126+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserverlibrary.js[m[K[36m[K:[m[K[32m[K99121[m[K[36m[K:[m[K // If he number will be printed ver[1;33m[Kbat[m[Kim and it doesn't already contain a dot, add one

1127+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserverlibrary.js[m[K[36m[K:[m[K[32m[K101301[m[K[36m[K:[m[K * If `optimistic` is set, the first instance will use 'baseName' ver[1;33m[Kbat[m[Kim instead of 'baseName_1'

1128+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserverlibrary.js[m[K[36m[K:[m[K[32m[K106169[m[K[36m[K:[m[K // Get next [1;33m[Kbat[m[Kch of affected files

1129+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/tsserverlibrary.js[m[K[36m[K:[m[K[32m[K108823[m[K[36m[K:[m[K // Upon detecting a file change, wait for 250ms and then perform a recompilation. This gives [1;33m[Kbat[m[Kch

1130+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescript.js[m[K[36m[K:[m[K[32m[K3789[m[K[36m[K:[m[K // The advantage of this approach is its simplicity. For the case of [1;33m[Kbat[m[Kch compilation,

1131+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescript.js[m[K[36m[K:[m[K[32m[K37426[m[K[36m[K:[m[K // Literal files are always included ver[1;33m[Kbat[m[Kim. An "include" or "exclude" specification cannot

1132+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescript.js[m[K[36m[K:[m[K[32m[K48240[m[K[36m[K:[m[K var ver[1;33m[Kbat[m[KimTargetName = ts.unescapeLeadingUnderscores(target.escapedName);

1133+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescript.js[m[K[36m[K:[m[K[32m[K48241[m[K[36m[K:[m[K if (ver[1;33m[Kbat[m[KimTargetName === "export=" /* ExportEquals */ && (compilerOptions.esModuleInterop || compilerOptions.allowSyntheticDefaultImports)) {

1134+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescript.js[m[K[36m[K:[m[K[32m[K48243[m[K[36m[K:[m[K ver[1;33m[Kbat[m[KimTargetName = "default" /* Default */;

1135+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescript.js[m[K[36m[K:[m[K[32m[K48245[m[K[36m[K:[m[K var targetName = getInternalSymbolName(target, ver[1;33m[Kbat[m[KimTargetName);

1136+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescript.js[m[K[36m[K:[m[K[32m[K48290[m[K[36m[K:[m[K ts.factory.createImportSpecifier(localName !== ver[1;33m[Kbat[m[KimTargetName ? ts.factory.createIdentifier(ver[1;33m[Kbat[m[KimTargetName) : undefined, ts.factory.createIdentifier(localName))

1137+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescript.js[m[K[36m[K:[m[K[32m[K48299[m[K[36m[K:[m[K serializeExportSpecifier(ts.unescapeLeadingUnderscores(symbol.escapedName), specifier ? ver[1;33m[Kbat[m[KimTargetName : targetName, specifier && ts.isStringLiteralLike(specifier) ? ts.factory.createStringLiteral(specifier.text) : undefined);

1138+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescript.js[m[K[36m[K:[m[K[32m[K99121[m[K[36m[K:[m[K // If he number will be printed ver[1;33m[Kbat[m[Kim and it doesn't already contain a dot, add one

1139+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescript.js[m[K[36m[K:[m[K[32m[K101301[m[K[36m[K:[m[K * If `optimistic` is set, the first instance will use 'baseName' ver[1;33m[Kbat[m[Kim instead of 'baseName_1'

1140+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescript.js[m[K[36m[K:[m[K[32m[K106169[m[K[36m[K:[m[K // Get next [1;33m[Kbat[m[Kch of affected files

1141+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/typescript.js[m[K[36m[K:[m[K[32m[K108823[m[K[36m[K:[m[K // Upon detecting a file change, wait for 250ms and then perform a recompilation. This gives [1;33m[Kbat[m[Kch

1142+[35m[Kassets/syntaxes/02_Extra/TypeScript/tsserver/lib.scripthost.d.ts[m[K[36m[K:[m[K[32m[K161[m[K[36m[K:[m[K * Gets/sets the script mode - interactive(true) or [1;33m[Kbat[m[Kch(false).

1145+[35m[Kassets/syntaxes/02_Extra/Org mode/README.org[m[K[36m[K:[m[K[32m[K25[m[K[36m[K:[m[K- [X] =Ver[1;33m[Kbat[m[Kim=

1146+[35m[Kassets/syntaxes/02_Extra/PowerShell/examples/test.ps1[m[K[36m[K:[m[K[32m[K281[m[K[36m[K:[m[Ka.[1;33m[Kbat[m[K

1147+[35m[Kassets/syntaxes/02_Extra/PowerShell/examples/test.ps1[m[K[36m[K:[m[K[32m[K282[m[K[36m[K:[m[Kaa.[1;33m[Kbat[m[K

1148+[35m[Kassets/syntaxes/02_Extra/PowerShell/examples/test.ps1[m[K[36m[K:[m[K[32m[K283[m[K[36m[K:[m[Kaaa.[1;33m[Kbat[m[K

1149+[35m[Kassets/syntaxes/02_Extra/PowerShell/examples/test.ps1[m[K[36m[K:[m[K[32m[K284[m[K[36m[K:[m[Kaaaa.[1;33m[Kbat[m[K

1150+[35m[Kassets/syntaxes/02_Extra/PowerShell/PowerShellSyntax.tmLanguage[m[K[36m[K:[m[K[32m[K255[m[K[36m[K:[m[K <string>(\b(([A-Za-z0-9\-_\.]+)\.(?i:exe|com|cmd|[1;33m[Kbat[m[K))\b)</string>

1151+[35m[Kassets/syntaxes/02_Extra/PowerShell/PowerShellSyntax.tmLanguage[m[K[36m[K:[m[K[32m[K503[m[K[36m[K:[m[K <string>(?:(\p{L}|\d|_|-|\\|\:)*\\)?\b(?i:Add|Approve|Assert|Backup|Block|Build|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy|Debug|Deny|Deploy|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|Format|Get|Grant|Group|Hide|Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Mount|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push|Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke|Save|Search|Select|Send|Set|Show|Skip|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Test|Trace|Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Write)\-.+?(?:\.(?i:exe|cmd|[1;33m[Kbat[m[K|ps1))?\b</string>

1152+[35m[Kassets/syntaxes/02_Extra/ssh-config/src/options.yaml[m[K[36m[K:[m[K[32m[K54[m[K[36m[K:[m[K [1;33m[KBat[m[KchMode:

1153+[35m[Kassets/syntaxes/02_Extra/ssh-config/SSH Config.sublime-syntax[m[K[36m[K:[m[K[32m[K215[m[K[36m[K:[m[K [1;33m[KBat[m[KchMode|CanonicalizeFallbackLocal|CheckHostIP|Compression|

1154+[35m[Kassets/syntaxes/02_Extra/ssh-config/Support/SSH Config.sublime-completions[m[K[36m[K:[m[K[32m[K41[m[K[36m[K:[m[K "trigger": "[1;33m[KBat[m[KchMode",

1155+[35m[Kassets/syntaxes/02_Extra/ssh-config/Support/SSH Config.sublime-completions[m[K[36m[K:[m[K[32m[K42[m[K[36m[K:[m[K "contents": "[1;33m[KBat[m[KchMode",

1156+[35m[Kassets/syntaxes/02_Extra/ssh-config/Support/SSH Config.sublime-completions[m[K[36m[K:[m[K[32m[K47[m[K[36m[K:[m[K "trigger": "[1;33m[Kbat[m[Kchmode",

1157+[35m[Kassets/syntaxes/02_Extra/ssh-config/Support/SSH Config.sublime-completions[m[K[36m[K:[m[K[32m[K48[m[K[36m[K:[m[K "contents": "[1;33m[KBat[m[KchMode ${0:{ yes | no \\}}",

1158+[35m[Kassets/syntaxes/02_Extra/http-request-response/README.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[KIt was originally designed for use in https://github.com/sharkdp/[1;33m[Kbat[m[K, so it is not using any Sublime Text 4 features, as https://github.com/trishume/syntect does not support them yet. So this package should work in Sublime Text 3 also.

1159+[35m[Kassets/syntaxes/02_Extra/http-request-response/docs/CONTRIBUTING.md[m[K[36m[K:[m[K[32m[K9[m[K[36m[K:[m[KIf you are not a Sublime Text user, and are contributing to improve a tool that uses the `syntect` Rust library, such as `[1;33m[Kbat[m[K`,

1161+[35m[Kassets/syntaxes/02_Extra/Lean/README.md[m[K[36m[K:[m[K[32m[K22[m[K[36m[K:[m[K* [1;33m[KBat[m[Kch file execution

1162+[35m[Kassets/syntaxes/02_Extra/Lean/README.md[m[K[36m[K:[m[K[32m[K178[m[K[36m[K:[m[K* `lean.[1;33m[Kbat[m[KchExecute` (Lean: [1;33m[KBat[m[Kch Execute File): execute the current file using Lean (bound to <kbd>ctrl</kbd>+<kbd>shift</kbd>+<kbd>r</kbd> by default)

1163+[35m[Kassets/syntaxes/02_Extra/Lean/README.md[m[K[36m[K:[m[K[32m[K287[m[K[36m[K:[m[K* Properly set working directory when executing in [1;33m[Kbat[m[Kch mode.

1164+[35m[Kassets/syntaxes/02_Extra/Lean/src/batch.ts[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[Klet [1;33m[Kbat[m[KchOutputChannel: OutputChannel;

1165+[35m[Kassets/syntaxes/02_Extra/Lean/src/batch.ts[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[Kexport function [1;33m[Kbat[m[KchExecuteFile(

1166+[35m[Kassets/syntaxes/02_Extra/Lean/src/batch.ts[m[K[36m[K:[m[K[32m[K13[m[K[36m[K:[m[K [1;33m[Kbat[m[KchOutputChannel = [1;33m[Kbat[m[KchOutputChannel ||

1167+[35m[Kassets/syntaxes/02_Extra/Lean/src/batch.ts[m[K[36m[K:[m[K[32m[K14[m[K[36m[K:[m[K window.createOutputChannel('Lean: [1;33m[KBat[m[Kch File Output');

1168+[35m[Kassets/syntaxes/02_Extra/Lean/src/batch.ts[m[K[36m[K:[m[K[32m[K23[m[K[36m[K:[m[K [1;33m[Kbat[m[KchOutputChannel.clear();

1169+[35m[Kassets/syntaxes/02_Extra/Lean/src/batch.ts[m[K[36m[K:[m[K[32m[K26[m[K[36m[K:[m[K [1;33m[Kbat[m[KchOutputChannel.appendLine(line);

1170+[35m[Kassets/syntaxes/02_Extra/Lean/src/batch.ts[m[K[36m[K:[m[K[32m[K30[m[K[36m[K:[m[K [1;33m[Kbat[m[KchOutputChannel.appendLine(line);

1171+[35m[Kassets/syntaxes/02_Extra/Lean/src/batch.ts[m[K[36m[K:[m[K[32m[K37[m[K[36m[K:[m[K [1;33m[Kbat[m[KchOutputChannel.show(true);

1172+[35m[Kassets/syntaxes/02_Extra/Lean/src/extension.ts[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[Kimport { [1;33m[Kbat[m[KchExecuteFile } from './[1;33m[Kbat[m[Kch';

1173+[35m[Kassets/syntaxes/02_Extra/Lean/src/extension.ts[m[K[36m[K:[m[K[32m[K67[m[K[36m[K:[m[K commands.registerTextEditorCommand('lean.[1;33m[Kbat[m[KchExecute',

1174+[35m[Kassets/syntaxes/02_Extra/Lean/src/extension.ts[m[K[36m[K:[m[K[32m[K68[m[K[36m[K:[m[K (editor, edit, args) => { [1;33m[Kbat[m[KchExecuteFile(server, editor, edit, args); }),

1175+[35m[Kassets/syntaxes/02_Extra/Lean/package.json[m[K[36m[K:[m[K[32m[K281[m[K[36m[K:[m[K "command": "lean.[1;33m[Kbat[m[KchExecute",

1176+[35m[Kassets/syntaxes/02_Extra/Lean/package.json[m[K[36m[K:[m[K[32m[K283[m[K[36m[K:[m[K "title": "[1;33m[KBat[m[Kch Execute File",

1177+[35m[Kassets/syntaxes/02_Extra/Lean/package.json[m[K[36m[K:[m[K[32m[K350[m[K[36m[K:[m[K "command": "lean.[1;33m[Kbat[m[KchExecute",

1178+[35m[Kassets/syntaxes/02_Extra/Lean/package.json[m[K[36m[K:[m[K[32m[K373[m[K[36m[K:[m[K "command": "lean.[1;33m[Kbat[m[KchExecute",

1179+[35m[Kassets/syntaxes/02_Extra/Lean/syntaxes/lean-markdown.json[m[K[36m[K:[m[K[32m[K571[m[K[36m[K:[m[K "fenced_code_block_dos[1;33m[Kbat[m[Kch": {

1180+[35m[Kassets/syntaxes/02_Extra/Lean/syntaxes/lean-markdown.json[m[K[36m[K:[m[K[32m[K572[m[K[36m[K:[m[K "begin": "(^)(\\s*)(`{3,}|~{3,})\\s*(?i:([1;33m[Kbat[m[K|[1;33m[Kbat[m[Kch)((\\s+|:|\\{)[^`~]*)?$)",

1181+[35m[Kassets/syntaxes/02_Extra/Lean/syntaxes/lean-markdown.json[m[K[36m[K:[m[K[32m[K595[m[K[36m[K:[m[K "contentName": "meta.embedded.block.dos[1;33m[Kbat[m[Kch",

1182+[35m[Kassets/syntaxes/02_Extra/Lean/syntaxes/lean-markdown.json[m[K[36m[K:[m[K[32m[K598[m[K[36m[K:[m[K "include": "source.[1;33m[Kbat[m[Kchfile"

1183+[35m[Kassets/syntaxes/02_Extra/Lean/syntaxes/lean-markdown.json[m[K[36m[K:[m[K[32m[K1774[m[K[36m[K:[m[K "include": "#fenced_code_block_dos[1;33m[Kbat[m[Kch"

1184+[35m[Kassets/syntaxes/02_Extra/Lean/syntaxes/lean.json[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[K { "match": "\\[1;33m[Kbat[m[Ktribute\\b\\s*\\[[^\\]]*\\]", "name": "storage.modifier.lean" },

1185+[35m[Kassets/syntaxes/02_Extra/Lean/package-lock.json[m[K[36m[K:[m[K[32m[K1946[m[K[36m[K:[m[K "integrity": "sha512-b39T[1;33m[KBaT[m[KSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",

1186+[35m[Kassets/syntaxes/02_Extra/Lean/package-lock.json[m[K[36m[K:[m[K[32m[K4288[m[K[36m[K:[m[K "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJ[1;33m[KBAt[m[K2rzfoa/5QBGBhxDix1dMt2kQKQ==",

1187+[35m[Kassets/syntaxes/02_Extra/Lean/package-lock.json[m[K[36m[K:[m[K[32m[K7099[m[K[36m[K:[m[K "integrity": "sha512-b39T[1;33m[KBaT[m[KSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",

1188+[35m[Kassets/syntaxes/02_Extra/Lean/package-lock.json[m[K[36m[K:[m[K[32m[K9705[m[K[36m[K:[m[K "integrity": "sha512-b39T[1;33m[KBaT[m[KSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",

1189+[35m[Kassets/syntaxes/02_Extra/Lean/package-lock.json[m[K[36m[K:[m[K[32m[K11662[m[K[36m[K:[m[K "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJ[1;33m[KBAt[m[K2rzfoa/5QBGBhxDix1dMt2kQKQ==",

1190+[35m[Kassets/syntaxes/02_Extra/Lean/package-lock.json[m[K[36m[K:[m[K[32m[K14054[m[K[36m[K:[m[K "integrity": "sha512-b39T[1;33m[KBaT[m[KSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",

1191+[35m[Kassets/syntaxes/02_Extra/CMake/CMakeCommands.yml[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[Kadd_custom_command: [OUTPUT, COMMAND, ARGS, MAIN_DEPENDENCY, DEPENDS, BYPRODUCTS, IMPLICIT_DEPENDS, WORKING_DIRECTORY, COMMENT, DEPFILE, VER[1;33m[KBAT[m[KIM, APPEND, USES_TERMINAL COMMAND_EXPAND_LISTS, TARGET, PRE_BUILD, PRE_LINK, POST_BUILD]

1192+[35m[Kassets/syntaxes/02_Extra/CMake/CMakeCommands.yml[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[Kadd_custom_target: [ALL, COMMAND, DEPENDS, BYPRODUCTS, WORKING_DIRECTORY, COMMENT, VER[1;33m[KBAT[m[KIM, USES_TERMINAL, COMMAND_EXPAND_LISTS, SOURCES]

1193+[35m[Kassets/syntaxes/02_Extra/CMake/CMakeVariables.sublime-completions[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K{"completions":[{"contents":"ANDROID","trigger":"ANDROID\tbuiltin variable"},{"contents":"APPLE","trigger":"APPLE\tbuiltin variable"},{"contents":"BORLAND","trigger":"BORLAND\tbuiltin variable"},{"contents":"BUILD_SHARED_LIBS","trigger":"BUILD_SHARED_LIBS\tbuiltin variable"},{"contents":"CACHE","trigger":"CACHE\tbuiltin variable"},{"contents":"CMAKE_ABSOLUTE_DESTINATION_FILES","trigger":"CMAKE_ABSOLUTE_DESTINATION_FILES\tbuiltin variable"},{"contents":"CMAKE_AIX_EXPORT_ALL_SYMBOLS","trigger":"CMAKE_AIX_EXPORT_ALL_SYMBOLS\tbuiltin variable"},{"contents":"CMAKE_ANDROID_ANT_ADDITIONAL_OPTIONS","trigger":"CMAKE_ANDROID_ANT_ADDITIONAL_OPTIONS\tbuiltin variable"},{"contents":"CMAKE_ANDROID_API","trigger":"CMAKE_ANDROID_API\tbuiltin variable"},{"contents":"CMAKE_ANDROID_API_MIN","trigger":"CMAKE_ANDROID_API_MIN\tbuiltin variable"},{"contents":"CMAKE_ANDROID_ARCH","trigger":"CMAKE_ANDROID_ARCH\tbuiltin variable"},{"contents":"CMAKE_ANDROID_ARCH_ABI","trigger":"CMAKE_ANDROID_ARCH_ABI\tbuiltin variable"},{"contents":"CMAKE_ANDROID_ARM_MODE","trigger":"CMAKE_ANDROID_ARM_MODE\tbuiltin variable"},{"contents":"CMAKE_ANDROID_ARM_NEON","trigger":"CMAKE_ANDROID_ARM_NEON\tbuiltin variable"},{"contents":"CMAKE_ANDROID_ASSETS_DIRECTORIES","trigger":"CMAKE_ANDROID_ASSETS_DIRECTORIES\tbuiltin variable"},{"contents":"CMAKE_ANDROID_GUI","trigger":"CMAKE_ANDROID_GUI\tbuiltin variable"},{"contents":"CMAKE_ANDROID_JAR_DEPENDENCIES","trigger":"CMAKE_ANDROID_JAR_DEPENDENCIES\tbuiltin variable"},{"contents":"CMAKE_ANDROID_JAR_DIRECTORIES","trigger":"CMAKE_ANDROID_JAR_DIRECTORIES\tbuiltin variable"},{"contents":"CMAKE_ANDROID_JAVA_SOURCE_DIR","trigger":"CMAKE_ANDROID_JAVA_SOURCE_DIR\tbuiltin variable"},{"contents":"CMAKE_ANDROID_NATIVE_LIB_DEPENDENCIES","trigger":"CMAKE_ANDROID_NATIVE_LIB_DEPENDENCIES\tbuiltin variable"},{"contents":"CMAKE_ANDROID_NATIVE_LIB_DIRECTORIES","trigger":"CMAKE_ANDROID_NATIVE_LIB_DIRECTORIES\tbuiltin variable"},{"contents":"CMAKE_ANDROID_NDK","trigger":"CMAKE_ANDROID_NDK\tbuiltin variable"},{"contents":"CMAKE_ANDROID_NDK_DEPRECATED_HEADERS","trigger":"CMAKE_ANDROID_NDK_DEPRECATED_HEADERS\tbuiltin variable"},{"contents":"CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG","trigger":"CMAKE_ANDROID_NDK_TOOLCHAIN_HOST_TAG\tbuiltin variable"},{"contents":"CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION","trigger":"CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION\tbuiltin variable"},{"contents":"CMAKE_ANDROID_PROCESS_MAX","trigger":"CMAKE_ANDROID_PROCESS_MAX\tbuiltin variable"},{"contents":"CMAKE_ANDROID_PROGUARD","trigger":"CMAKE_ANDROID_PROGUARD\tbuiltin variable"},{"contents":"CMAKE_ANDROID_PROGUARD_CONFIG_PATH","trigger":"CMAKE_ANDROID_PROGUARD_CONFIG_PATH\tbuiltin variable"},{"contents":"CMAKE_ANDROID_SECURE_PROPS_PATH","trigger":"CMAKE_ANDROID_SECURE_PROPS_PATH\tbuiltin variable"},{"contents":"CMAKE_ANDROID_SKIP_ANT_STEP","trigger":"CMAKE_ANDROID_SKIP_ANT_STEP\tbuiltin variable"},{"contents":"CMAKE_ANDROID_STANDALONE_TOOLCHAIN","trigger":"CMAKE_ANDROID_STANDALONE_TOOLCHAIN\tbuiltin variable"},{"contents":"CMAKE_ANDROID_STL_TYPE","trigger":"CMAKE_ANDROID_STL_TYPE\tbuiltin variable"},{"contents":"CMAKE_APPBUNDLE_PATH","trigger":"CMAKE_APPBUNDLE_PATH\tbuiltin variable"},{"contents":"CMAKE_APPLE_SILICON_PROCESSOR","trigger":"CMAKE_APPLE_SILICON_PROCESSOR\tbuiltin variable"},{"contents":"CMAKE_AR","trigger":"CMAKE_AR\tbuiltin variable"},{"contents":"CMAKE_ARCHIVE_OUTPUT_DIRECTORY","trigger":"CMAKE_ARCHIVE_OUTPUT_DIRECTORY\tbuiltin variable"},{"contents":"CMAKE_ARGC","trigger":"CMAKE_ARGC\tbuiltin variable"},{"contents":"CMAKE_ARGV0","trigger":"CMAKE_ARGV0\tbuiltin variable"},{"contents":"CMAKE_AUTOGEN_ORIGIN_DEPENDS","trigger":"CMAKE_AUTOGEN_ORIGIN_DEPENDS\tbuiltin variable"},{"contents":"CMAKE_AUTOGEN_PARALLEL","trigger":"CMAKE_AUTOGEN_PARALLEL\tbuiltin variable"},{"contents":"CMAKE_AUTOGEN_VERBOSE","trigger":"CMAKE_AUTOGEN_VERBOSE\tbuiltin variable"},{"contents":"CMAKE_AUTOMOC","trigger":"CMAKE_AUTOMOC\tbuiltin variable"},{"contents":"CMAKE_AUTOMOC_COMPILER_PREDEFINES","trigger":"CMAKE_AUTOMOC_COMPILER_PREDEFINES\tbuiltin variable"},{"contents":"CMAKE_AUTOMOC_DEPEND_FILTERS","trigger":"CMAKE_AUTOMOC_DEPEND_FILTERS\tbuiltin variable"},{"contents":"CMAKE_AUTOMOC_MACRO_NAMES","trigger":"CMAKE_AUTOMOC_MACRO_NAMES\tbuiltin variable"},{"contents":"CMAKE_AUTOMOC_MOC_OPTIONS","trigger":"CMAKE_AUTOMOC_MOC_OPTIONS\tbuiltin variable"},{"contents":"CMAKE_AUTOMOC_PATH_PREFIX","trigger":"CMAKE_AUTOMOC_PATH_PREFIX\tbuiltin variable"},{"contents":"CMAKE_AUTOMOC_RELAXED_MODE","trigger":"CMAKE_AUTOMOC_RELAXED_MODE\tbuiltin variable"},{"contents":"CMAKE_AUTORCC","trigger":"CMAKE_AUTORCC\tbuiltin variable"},{"contents":"CMAKE_AUTORCC_OPTIONS","trigger":"CMAKE_AUTORCC_OPTIONS\tbuiltin variable"},{"contents":"CMAKE_AUTOUIC","trigger":"CMAKE_AUTOUIC\tbuiltin variable"},{"contents":"CMAKE_AUTOUIC_OPTIONS","trigger":"CMAKE_AUTOUIC_OPTIONS\tbuiltin variable"},{"contents":"CMAKE_AUTOUIC_SEARCH_PATHS","trigger":"CMAKE_AUTOUIC_SEARCH_PATHS\tbuiltin variable"},{"contents":"CMAKE_BACKWARDS_COMPATIBILITY","trigger":"CMAKE_BACKWARDS_COMPATIBILITY\tbuiltin variable"},{"contents":"CMAKE_BINARY_DIR","trigger":"CMAKE_BINARY_DIR\tbuiltin variable"},{"contents":"CMAKE_BUILD_RPATH","trigger":"CMAKE_BUILD_RPATH\tbuiltin variable"},{"contents":"CMAKE_BUILD_RPATH_USE_ORIGIN","trigger":"CMAKE_BUILD_RPATH_USE_ORIGIN\tbuiltin variable"},{"contents":"CMAKE_BUILD_TOOL","trigger":"CMAKE_BUILD_TOOL\tbuiltin variable"},{"contents":"CMAKE_BUILD_TYPE","trigger":"CMAKE_BUILD_TYPE\tbuiltin variable"},{"contents":"CMAKE_BUILD_WITH_INSTALL_NAME_DIR","trigger":"CMAKE_BUILD_WITH_INSTALL_NAME_DIR\tbuiltin variable"},{"contents":"CMAKE_BUILD_WITH_INSTALL_RPATH","trigger":"CMAKE_BUILD_WITH_INSTALL_RPATH\tbuiltin variable"},{"contents":"CMAKE_CACHEFILE_DIR","trigger":"CMAKE_CACHEFILE_DIR\tbuiltin variable"},{"contents":"CMAKE_CACHE_MAJOR_VERSION","trigger":"CMAKE_CACHE_MAJOR_VERSION\tbuiltin variable"},{"contents":"CMAKE_CACHE_MINOR_VERSION","trigger":"CMAKE_CACHE_MINOR_VERSION\tbuiltin variable"},{"contents":"CMAKE_CACHE_PATCH_VERSION","trigger":"CMAKE_CACHE_PATCH_VERSION\tbuiltin variable"},{"contents":"CMAKE_CFG_INTDIR","trigger":"CMAKE_CFG_INTDIR\tbuiltin variable"},{"contents":"CMAKE_CLANG_VFS_OVERLAY","trigger":"CMAKE_CLANG_VFS_OVERLAY\tbuiltin variable"},{"contents":"CMAKE_CL_64","trigger":"CMAKE_CL_64\tbuiltin variable"},{"contents":"CMAKE_CODEBLOCKS_COMPILER_ID","trigger":"CMAKE_CODEBLOCKS_COMPILER_ID\tbuiltin variable"},{"contents":"CMAKE_CODEBLOCKS_EXCLUDE_EXTERNAL_FILES","trigger":"CMAKE_CODEBLOCKS_EXCLUDE_EXTERNAL_FILES\tbuiltin variable"},{"contents":"CMAKE_CODELITE_USE_TARGETS","trigger":"CMAKE_CODELITE_USE_TARGETS\tbuiltin variable"},{"contents":"CMAKE_COLOR_MAKEFILE","trigger":"CMAKE_COLOR_MAKEFILE\tbuiltin variable"},{"contents":"CMAKE_COMMAND","trigger":"CMAKE_COMMAND\tbuiltin variable"},{"contents":"CMAKE_COMPILER_2005","trigger":"CMAKE_COMPILER_2005\tbuiltin variable"},{"contents":"CMAKE_COMPILER_IS_GNUCC","trigger":"CMAKE_COMPILER_IS_GNUCC\tbuiltin variable"},{"contents":"CMAKE_COMPILER_IS_GNUCXX","trigger":"CMAKE_COMPILER_IS_GNUCXX\tbuiltin variable"},{"contents":"CMAKE_COMPILER_IS_GNUG77","trigger":"CMAKE_COMPILER_IS_GNUG77\tbuiltin variable"},{"contents":"CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY","trigger":"CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY\tbuiltin variable"},{"contents":"CMAKE_CONFIGURATION_TYPES","trigger":"CMAKE_CONFIGURATION_TYPES\tbuiltin variable"},{"contents":"CMAKE_CPACK_COMMAND","trigger":"CMAKE_CPACK_COMMAND\tbuiltin variable"},{"contents":"CMAKE_CROSSCOMPILING","trigger":"CMAKE_CROSSCOMPILING\tbuiltin variable"},{"contents":"CMAKE_CROSSCOMPILING_EMULATOR","trigger":"CMAKE_CROSSCOMPILING_EMULATOR\tbuiltin variable"},{"contents":"CMAKE_CROSS_CONFIGS","trigger":"CMAKE_CROSS_CONFIGS\tbuiltin variable"},{"contents":"CMAKE_CTEST_ARGUMENTS","trigger":"CMAKE_CTEST_ARGUMENTS\tbuiltin variable"},{"contents":"CMAKE_CTEST_COMMAND","trigger":"CMAKE_CTEST_COMMAND\tbuiltin variable"},{"contents":"CMAKE_CUDA_ARCHITECTURES","trigger":"CMAKE_CUDA_ARCHITECTURES\tbuiltin variable"},{"contents":"CMAKE_CUDA_COMPILE_FEATURES","trigger":"CMAKE_CUDA_COMPILE_FEATURES\tbuiltin variable"},{"contents":"CMAKE_CUDA_EXTENSIONS","trigger":"CMAKE_CUDA_EXTENSIONS\tbuiltin variable"},{"contents":"CMAKE_CUDA_HOST_COMPILER","trigger":"CMAKE_CUDA_HOST_COMPILER\tbuiltin variable"},{"contents":"CMAKE_CUDA_RESOLVE_DEVICE_SYMBOLS","trigger":"CMAKE_CUDA_RESOLVE_DEVICE_SYMBOLS\tbuiltin variable"},{"contents":"CMAKE_CUDA_RUNTIME_LIBRARY","trigger":"CMAKE_CUDA_RUNTIME_LIBRARY\tbuiltin variable"},{"contents":"CMAKE_CUDA_SEPARABLE_COMPILATION","trigger":"CMAKE_CUDA_SEPARABLE_COMPILATION\tbuiltin variable"},{"contents":"CMAKE_CUDA_STANDARD","trigger":"CMAKE_CUDA_STANDARD\tbuiltin variable"},{"contents":"CMAKE_CUDA_STANDARD_REQUIRED","trigger":"CMAKE_CUDA_STANDARD_REQUIRED\tbuiltin variable"},{"contents":"CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES","trigger":"CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES\tbuiltin variable"},{"contents":"CMAKE_CURRENT_BINARY_DIR","trigger":"CMAKE_CURRENT_BINARY_DIR\tbuiltin variable"},{"contents":"CMAKE_CURRENT_FUNCTION","trigger":"CMAKE_CURRENT_FUNCTION\tbuiltin variable"},{"contents":"CMAKE_CURRENT_FUNCTION_LIST_DIR","trigger":"CMAKE_CURRENT_FUNCTION_LIST_DIR\tbuiltin variable"},{"contents":"CMAKE_CURRENT_FUNCTION_LIST_FILE","trigger":"CMAKE_CURRENT_FUNCTION_LIST_FILE\tbuiltin variable"},{"contents":"CMAKE_CURRENT_FUNCTION_LIST_LINE","trigger":"CMAKE_CURRENT_FUNCTION_LIST_LINE\tbuiltin variable"},{"contents":"CMAKE_CURRENT_LIST_DIR","trigger":"CMAKE_CURRENT_LIST_DIR\tbuiltin variable"},{"contents":"CMAKE_CURRENT_LIST_FILE","trigger":"CMAKE_CURRENT_LIST_FILE\tbuiltin variable"},{"contents":"CMAKE_CURRENT_LIST_LINE","trigger":"CMAKE_CURRENT_LIST_LINE\tbuiltin variable"},{"contents":"CMAKE_CURRENT_SOURCE_DIR","trigger":"CMAKE_CURRENT_SOURCE_DIR\tbuiltin variable"},{"contents":"CMAKE_CXX_COMPILE_FEATURES","trigger":"CMAKE_CXX_COMPILE_FEATURES\tbuiltin variable"},{"contents":"CMAKE_CXX_EXTENSIONS","trigger":"CMAKE_CXX_EXTENSIONS\tbuiltin variable"},{"contents":"CMAKE_CXX_STANDARD","trigger":"CMAKE_CXX_STANDARD\tbuiltin variable"},{"contents":"CMAKE_CXX_STANDARD_REQUIRED","trigger":"CMAKE_CXX_STANDARD_REQUIRED\tbuiltin variable"},{"contents":"CMAKE_C_COMPILE_FEATURES","trigger":"CMAKE_C_COMPILE_FEATURES\tbuiltin variable"},{"contents":"CMAKE_C_EXTENSIONS","trigger":"CMAKE_C_EXTENSIONS\tbuiltin variable"},{"contents":"CMAKE_C_STANDARD","trigger":"CMAKE_C_STANDARD\tbuiltin variable"},{"contents":"CMAKE_C_STANDARD_REQUIRED","trigger":"CMAKE_C_STANDARD_REQUIRED\tbuiltin variable"},{"contents":"CMAKE_DEBUG_POSTFIX","trigger":"CMAKE_DEBUG_POSTFIX\tbuiltin variable"},{"contents":"CMAKE_DEBUG_TARGET_PROPERTIES","trigger":"CMAKE_DEBUG_TARGET_PROPERTIES\tbuiltin variable"},{"contents":"CMAKE_DEFAULT_BUILD_TYPE","trigger":"CMAKE_DEFAULT_BUILD_TYPE\tbuiltin variable"},{"contents":"CMAKE_DEFAULT_CONFIGS","trigger":"CMAKE_DEFAULT_CONFIGS\tbuiltin variable"},{"contents":"CMAKE_DEPENDS_IN_PROJECT_ONLY","trigger":"CMAKE_DEPENDS_IN_PROJECT_ONLY\tbuiltin variable"},{"contents":"CMAKE_DIRECTORY_LABELS","trigger":"CMAKE_DIRECTORY_LABELS\tbuiltin variable"},{"contents":"CMAKE_DISABLE_PRECOMPILE_HEADERS","trigger":"CMAKE_DISABLE_PRECOMPILE_HEADERS\tbuiltin variable"},{"contents":"CMAKE_DL_LIBS","trigger":"CMAKE_DL_LIBS\tbuiltin variable"},{"contents":"CMAKE_DOTNET_TARGET_FRAMEWORK","trigger":"CMAKE_DOTNET_TARGET_FRAMEWORK\tbuiltin variable"},{"contents":"CMAKE_DOTNET_TARGET_FRAMEWORK_VERSION","trigger":"CMAKE_DOTNET_TARGET_FRAMEWORK_VERSION\tbuiltin variable"},{"contents":"CMAKE_ECLIPSE_GENERATE_LINKED_RESOURCES","trigger":"CMAKE_ECLIPSE_GENERATE_LINKED_RESOURCES\tbuiltin variable"},{"contents":"CMAKE_ECLIPSE_GENERATE_SOURCE_PROJECT","trigger":"CMAKE_ECLIPSE_GENERATE_SOURCE_PROJECT\tbuiltin variable"},{"contents":"CMAKE_ECLIPSE_MAKE_ARGUMENTS","trigger":"CMAKE_ECLIPSE_MAKE_ARGUMENTS\tbuiltin variable"},{"contents":"CMAKE_ECLIPSE_RESOURCE_ENCODING","trigger":"CMAKE_ECLIPSE_RESOURCE_ENCODING\tbuiltin variable"},{"contents":"CMAKE_ECLIPSE_VERSION","trigger":"CMAKE_ECLIPSE_VERSION\tbuiltin variable"},{"contents":"CMAKE_EDIT_COMMAND","trigger":"CMAKE_EDIT_COMMAND\tbuiltin variable"},{"contents":"CMAKE_ENABLE_EXPORTS","trigger":"CMAKE_ENABLE_EXPORTS\tbuiltin variable"},{"contents":"CMAKE_ERROR_DEPRECATED","trigger":"CMAKE_ERROR_DEPRECATED\tbuiltin variable"},{"contents":"CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION","trigger":"CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION\tbuiltin variable"},{"contents":"CMAKE_EXECUTABLE_SUFFIX","trigger":"CMAKE_EXECUTABLE_SUFFIX\tbuiltin variable"},{"contents":"CMAKE_EXECUTE_PROCESS_COMMAND_ECHO","trigger":"CMAKE_EXECUTE_PROCESS_COMMAND_ECHO\tbuiltin variable"},{"contents":"CMAKE_EXE_LINKER_FLAGS","trigger":"CMAKE_EXE_LINKER_FLAGS\tbuiltin variable"},{"contents":"CMAKE_EXE_LINKER_FLAGS_INIT","trigger":"CMAKE_EXE_LINKER_FLAGS_INIT\tbuiltin variable"},{"contents":"CMAKE_EXPORT_COMPILE_COMMANDS","trigger":"CMAKE_EXPORT_COMPILE_COMMANDS\tbuiltin variable"},{"contents":"CMAKE_EXPORT_NO_PACKAGE_REGISTRY","trigger":"CMAKE_EXPORT_NO_PACKAGE_REGISTRY\tbuiltin variable"},{"contents":"CMAKE_EXPORT_PACKAGE_REGISTRY","trigger":"CMAKE_EXPORT_PACKAGE_REGISTRY\tbuiltin variable"},{"contents":"CMAKE_EXTRA_GENERATOR","trigger":"CMAKE_EXTRA_GENERATOR\tbuiltin variable"},{"contents":"CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES","trigger":"CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES\tbuiltin variable"},{"contents":"CMAKE_FIND_APPBUNDLE","trigger":"CMAKE_FIND_APPBUNDLE\tbuiltin variable"},{"contents":"CMAKE_FIND_DEBUG_MODE","trigger":"CMAKE_FIND_DEBUG_MODE\tbuiltin variable"},{"contents":"CMAKE_FIND_FRAMEWORK","trigger":"CMAKE_FIND_FRAMEWORK\tbuiltin variable"},{"contents":"CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX","trigger":"CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX\tbuiltin variable"},{"contents":"CMAKE_FIND_LIBRARY_PREFIXES","trigger":"CMAKE_FIND_LIBRARY_PREFIXES\tbuiltin variable"},{"contents":"CMAKE_FIND_LIBRARY_SUFFIXES","trigger":"CMAKE_FIND_LIBRARY_SUFFIXES\tbuiltin variable"},{"contents":"CMAKE_FIND_NO_INSTALL_PREFIX","trigger":"CMAKE_FIND_NO_INSTALL_PREFIX\tbuiltin variable"},{"contents":"CMAKE_FIND_PACKAGE_NAME","trigger":"CMAKE_FIND_PACKAGE_NAME\tbuiltin variable"},{"contents":"CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY","trigger":"CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY\tbuiltin variable"},{"contents":"CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY","trigger":"CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY\tbuiltin variable"},{"contents":"CMAKE_FIND_PACKAGE_PREFER_CONFIG","trigger":"CMAKE_FIND_PACKAGE_PREFER_CONFIG\tbuiltin variable"},{"contents":"CMAKE_FIND_PACKAGE_RESOLVE_SYMLINKS","trigger":"CMAKE_FIND_PACKAGE_RESOLVE_SYMLINKS\tbuiltin variable"},{"contents":"CMAKE_FIND_PACKAGE_SORT_DIRECTION","trigger":"CMAKE_FIND_PACKAGE_SORT_DIRECTION\tbuiltin variable"},{"contents":"CMAKE_FIND_PACKAGE_SORT_ORDER","trigger":"CMAKE_FIND_PACKAGE_SORT_ORDER\tbuiltin variable"},{"contents":"CMAKE_FIND_PACKAGE_WARN_NO_MODULE","trigger":"CMAKE_FIND_PACKAGE_WARN_NO_MODULE\tbuiltin variable"},{"contents":"CMAKE_FIND_ROOT_PATH","trigger":"CMAKE_FIND_ROOT_PATH\tbuiltin variable"},{"contents":"CMAKE_FIND_ROOT_PATH_MODE_INCLUDE","trigger":"CMAKE_FIND_ROOT_PATH_MODE_INCLUDE\tbuiltin variable"},{"contents":"CMAKE_FIND_ROOT_PATH_MODE_LIBRARY","trigger":"CMAKE_FIND_ROOT_PATH_MODE_LIBRARY\tbuiltin variable"},{"contents":"CMAKE_FIND_ROOT_PATH_MODE_PACKAGE","trigger":"CMAKE_FIND_ROOT_PATH_MODE_PACKAGE\tbuiltin variable"},{"contents":"CMAKE_FIND_ROOT_PATH_MODE_PROGRAM","trigger":"CMAKE_FIND_ROOT_PATH_MODE_PROGRAM\tbuiltin variable"},{"contents":"CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH","trigger":"CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH\tbuiltin variable"},{"contents":"CMAKE_FIND_USE_CMAKE_PATH","trigger":"CMAKE_FIND_USE_CMAKE_PATH\tbuiltin variable"},{"contents":"CMAKE_FIND_USE_CMAKE_SYSTEM_PATH","trigger":"CMAKE_FIND_USE_CMAKE_SYSTEM_PATH\tbuiltin variable"},{"contents":"CMAKE_FIND_USE_PACKAGE_REGISTRY","trigger":"CMAKE_FIND_USE_PACKAGE_REGISTRY\tbuiltin variable"},{"contents":"CMAKE_FIND_USE_PACKAGE_ROOT_PATH","trigger":"CMAKE_FIND_USE_PACKAGE_ROOT_PATH\tbuiltin variable"},{"contents":"CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH","trigger":"CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH\tbuiltin variable"},{"contents":"CMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY","trigger":"CMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY\tbuiltin variable"},{"contents":"CMAKE_FOLDER","trigger":"CMAKE_FOLDER\tbuiltin variable"},{"contents":"CMAKE_FRAMEWORK","trigger":"CMAKE_FRAMEWORK\tbuiltin variable"},{"contents":"CMAKE_FRAMEWORK_PATH","trigger":"CMAKE_FRAMEWORK_PATH\tbuiltin variable"},{"contents":"CMAKE_Fortran_FORMAT","trigger":"CMAKE_Fortran_FORMAT\tbuiltin variable"},{"contents":"CMAKE_Fortran_MODDIR_DEFAULT","trigger":"CMAKE_Fortran_MODDIR_DEFAULT\tbuiltin variable"},{"contents":"CMAKE_Fortran_MODDIR_FLAG","trigger":"CMAKE_Fortran_MODDIR_FLAG\tbuiltin variable"},{"contents":"CMAKE_Fortran_MODOUT_FLAG","trigger":"CMAKE_Fortran_MODOUT_FLAG\tbuiltin variable"},{"contents":"CMAKE_Fortran_MODULE_DIRECTORY","trigger":"CMAKE_Fortran_MODULE_DIRECTORY\tbuiltin variable"},{"contents":"CMAKE_Fortran_PREPROCESS","trigger":"CMAKE_Fortran_PREPROCESS\tbuiltin variable"},{"contents":"CMAKE_GENERATOR","trigger":"CMAKE_GENERATOR\tbuiltin variable"},{"contents":"CMAKE_GENERATOR_INSTANCE","trigger":"CMAKE_GENERATOR_INSTANCE\tbuiltin variable"},{"contents":"CMAKE_GENERATOR_PLATFORM","trigger":"CMAKE_GENERATOR_PLATFORM\tbuiltin variable"},{"contents":"CMAKE_GENERATOR_TOOLSET","trigger":"CMAKE_GENERATOR_TOOLSET\tbuiltin variable"},{"contents":"CMAKE_GHS_NO_SOURCE_GROUP_FILE","trigger":"CMAKE_GHS_NO_SOURCE_GROUP_FILE\tbuiltin variable"},{"contents":"CMAKE_GLOBAL_AUTOGEN_TARGET","trigger":"CMAKE_GLOBAL_AUTOGEN_TARGET\tbuiltin variable"},{"contents":"CMAKE_GLOBAL_AUTOGEN_TARGET_NAME","trigger":"CMAKE_GLOBAL_AUTOGEN_TARGET_NAME\tbuiltin variable"},{"contents":"CMAKE_GLOBAL_AUTORCC_TARGET","trigger":"CMAKE_GLOBAL_AUTORCC_TARGET\tbuiltin variable"},{"contents":"CMAKE_GLOBAL_AUTORCC_TARGET_NAME","trigger":"CMAKE_GLOBAL_AUTORCC_TARGET_NAME\tbuiltin variable"},{"contents":"CMAKE_GNUtoMS","trigger":"CMAKE_GNUtoMS\tbuiltin variable"},{"contents":"CMAKE_HOME_DIRECTORY","trigger":"CMAKE_HOME_DIRECTORY\tbuiltin variable"},{"contents":"CMAKE_HOST_APPLE","trigger":"CMAKE_HOST_APPLE\tbuiltin variable"},{"contents":"CMAKE_HOST_SOLARIS","trigger":"CMAKE_HOST_SOLARIS\tbuiltin variable"},{"contents":"CMAKE_HOST_SYSTEM","trigger":"CMAKE_HOST_SYSTEM\tbuiltin variable"},{"contents":"CMAKE_HOST_SYSTEM_NAME","trigger":"CMAKE_HOST_SYSTEM_NAME\tbuiltin variable"},{"contents":"CMAKE_HOST_SYSTEM_PROCESSOR","trigger":"CMAKE_HOST_SYSTEM_PROCESSOR\tbuiltin variable"},{"contents":"CMAKE_HOST_SYSTEM_VERSION","trigger":"CMAKE_HOST_SYSTEM_VERSION\tbuiltin variable"},{"contents":"CMAKE_HOST_UNIX","trigger":"CMAKE_HOST_UNIX\tbuiltin variable"},{"contents":"CMAKE_HOST_WIN32","trigger":"CMAKE_HOST_WIN32\tbuiltin variable"},{"contents":"CMAKE_IGNORE_PATH","trigger":"CMAKE_IGNORE_PATH\tbuiltin variable"},{"contents":"CMAKE_IMPORT_LIBRARY_PREFIX","trigger":"CMAKE_IMPORT_LIBRARY_PREFIX\tbuiltin variable"},{"contents":"CMAKE_IMPORT_LIBRARY_SUFFIX","trigger":"CMAKE_IMPORT_LIBRARY_SUFFIX\tbuiltin variable"},{"contents":"CMAKE_INCLUDE_CURRENT_DIR","trigger":"CMAKE_INCLUDE_CURRENT_DIR\tbuiltin variable"},{"contents":"CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE","trigger":"CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE\tbuiltin variable"},{"contents":"CMAKE_INCLUDE_DIRECTORIES_BEFORE","trigger":"CMAKE_INCLUDE_DIRECTORIES_BEFORE\tbuiltin variable"},{"contents":"CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE","trigger":"CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE\tbuiltin variable"},{"contents":"CMAKE_INCLUDE_PATH","trigger":"CMAKE_INCLUDE_PATH\tbuiltin variable"},{"contents":"CMAKE_INSTALL_DEFAULT_COMPONENT_NAME","trigger":"CMAKE_INSTALL_DEFAULT_COMPONENT_NAME\tbuiltin variable"},{"contents":"CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS","trigger":"CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS\tbuiltin variable"},{"contents":"CMAKE_INSTALL_MESSAGE","trigger":"CMAKE_INSTALL_MESSAGE\tbuiltin variable"},{"contents":"CMAKE_INSTALL_NAME_DIR","trigger":"CMAKE_INSTALL_NAME_DIR\tbuiltin variable"},{"contents":"CMAKE_INSTALL_PREFIX","trigger":"CMAKE_INSTALL_PREFIX\tbuiltin variable"},{"contents":"CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT","trigger":"CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT\tbuiltin variable"},{"contents":"CMAKE_INSTALL_REMOVE_ENVIRONMENT_RPATH","trigger":"CMAKE_INSTALL_REMOVE_ENVIRONMENT_RPATH\tbuiltin variable"},{"contents":"CMAKE_INSTALL_RPATH","trigger":"CMAKE_INSTALL_RPATH\tbuiltin variable"},{"contents":"CMAKE_INSTALL_RPATH_USE_LINK_PATH","trigger":"CMAKE_INSTALL_RPATH_USE_LINK_PATH\tbuiltin variable"},{"contents":"CMAKE_INTERNAL_PLATFORM_ABI","trigger":"CMAKE_INTERNAL_PLATFORM_ABI\tbuiltin variable"},{"contents":"CMAKE_INTERPROCEDURAL_OPTIMIZATION","trigger":"CMAKE_INTERPROCEDURAL_OPTIMIZATION\tbuiltin variable"},{"contents":"CMAKE_IOS_INSTALL_COMBINED","trigger":"CMAKE_IOS_INSTALL_COMBINED\tbuiltin variable"},{"contents":"CMAKE_ISPC_HEADER_DIRECTORY","trigger":"CMAKE_ISPC_HEADER_DIRECTORY\tbuiltin variable"},{"contents":"CMAKE_ISPC_HEADER_SUFFIX","trigger":"CMAKE_ISPC_HEADER_SUFFIX\tbuiltin variable"},{"contents":"CMAKE_ISPC_INSTRUCTION_SETS","trigger":"CMAKE_ISPC_INSTRUCTION_SETS\tbuiltin variable"},{"contents":"CMAKE_JOB_POOLS","trigger":"CMAKE_JOB_POOLS\tbuiltin variable"},{"contents":"CMAKE_JOB_POOL_COMPILE","trigger":"CMAKE_JOB_POOL_COMPILE\tbuiltin variable"},{"contents":"CMAKE_JOB_POOL_LINK","trigger":"CMAKE_JOB_POOL_LINK\tbuiltin variable"},{"contents":"CMAKE_JOB_POOL_PRECOMPILE_HEADER","trigger":"CMAKE_JOB_POOL_PRECOMPILE_HEADER\tbuiltin variable"},{"contents":"CMAKE_LIBRARY_ARCHITECTURE","trigger":"CMAKE_LIBRARY_ARCHITECTURE\tbuiltin variable"},{"contents":"CMAKE_LIBRARY_ARCHITECTURE_REGEX","trigger":"CMAKE_LIBRARY_ARCHITECTURE_REGEX\tbuiltin variable"},{"contents":"CMAKE_LIBRARY_OUTPUT_DIRECTORY","trigger":"CMAKE_LIBRARY_OUTPUT_DIRECTORY\tbuiltin variable"},{"contents":"CMAKE_LIBRARY_PATH","trigger":"CMAKE_LIBRARY_PATH\tbuiltin variable"},{"contents":"CMAKE_LIBRARY_PATH_FLAG","trigger":"CMAKE_LIBRARY_PATH_FLAG\tbuiltin variable"},{"contents":"CMAKE_LINK_DEF_FILE_FLAG","trigger":"CMAKE_LINK_DEF_FILE_FLAG\tbuiltin variable"},{"contents":"CMAKE_LINK_DEPENDS_NO_SHARED","trigger":"CMAKE_LINK_DEPENDS_NO_SHARED\tbuiltin variable"},{"contents":"CMAKE_LINK_DIRECTORIES_BEFORE","trigger":"CMAKE_LINK_DIRECTORIES_BEFORE\tbuiltin variable"},{"contents":"CMAKE_LINK_INTERFACE_LIBRARIES","trigger":"CMAKE_LINK_INTERFACE_LIBRARIES\tbuiltin variable"},{"contents":"CMAKE_LINK_LIBRARY_FILE_FLAG","trigger":"CMAKE_LINK_LIBRARY_FILE_FLAG\tbuiltin variable"},{"contents":"CMAKE_LINK_LIBRARY_FLAG","trigger":"CMAKE_LINK_LIBRARY_FLAG\tbuiltin variable"},{"contents":"CMAKE_LINK_LIBRARY_SUFFIX","trigger":"CMAKE_LINK_LIBRARY_SUFFIX\tbuiltin variable"},{"contents":"CMAKE_LINK_SEARCH_END_STATIC","trigger":"CMAKE_LINK_SEARCH_END_STATIC\tbuiltin variable"},{"contents":"CMAKE_LINK_SEARCH_START_STATIC","trigger":"CMAKE_LINK_SEARCH_START_STATIC\tbuiltin variable"},{"contents":"CMAKE_LINK_WHAT_YOU_USE","trigger":"CMAKE_LINK_WHAT_YOU_USE\tbuiltin variable"},{"contents":"CMAKE_MACOSX_BUNDLE","trigger":"CMAKE_MACOSX_BUNDLE\tbuiltin variable"},{"contents":"CMAKE_MACOSX_RPATH","trigger":"CMAKE_MACOSX_RPATH\tbuiltin variable"},{"contents":"CMAKE_MAJOR_VERSION","trigger":"CMAKE_MAJOR_VERSION\tbuiltin variable"},{"contents":"CMAKE_MAKE_PROGRAM","trigger":"CMAKE_MAKE_PROGRAM\tbuiltin variable"},{"contents":"CMAKE_MATCH_COUNT","trigger":"CMAKE_MATCH_COUNT\tbuiltin variable"},{"contents":"CMAKE_MAXIMUM_RECURSION_DEPTH","trigger":"CMAKE_MAXIMUM_RECURSION_DEPTH\tbuiltin variable"},{"contents":"CMAKE_MESSAGE_CONTEXT","trigger":"CMAKE_MESSAGE_CONTEXT\tbuiltin variable"},{"contents":"CMAKE_MESSAGE_CONTEXT_SHOW","trigger":"CMAKE_MESSAGE_CONTEXT_SHOW\tbuiltin variable"},{"contents":"CMAKE_MESSAGE_INDENT","trigger":"CMAKE_MESSAGE_INDENT\tbuiltin variable"},{"contents":"CMAKE_MESSAGE_LOG_LEVEL","trigger":"CMAKE_MESSAGE_LOG_LEVEL\tbuiltin variable"},{"contents":"CMAKE_MFC_FLAG","trigger":"CMAKE_MFC_FLAG\tbuiltin variable"},{"contents":"CMAKE_MINIMUM_REQUIRED_VERSION","trigger":"CMAKE_MINIMUM_REQUIRED_VERSION\tbuiltin variable"},{"contents":"CMAKE_MINOR_VERSION","trigger":"CMAKE_MINOR_VERSION\tbuiltin variable"},{"contents":"CMAKE_MODULE_LINKER_FLAGS","trigger":"CMAKE_MODULE_LINKER_FLAGS\tbuiltin variable"},{"contents":"CMAKE_MODULE_LINKER_FLAGS_INIT","trigger":"CMAKE_MODULE_LINKER_FLAGS_INIT\tbuiltin variable"},{"contents":"CMAKE_MODULE_PATH","trigger":"CMAKE_MODULE_PATH\tbuiltin variable"},{"contents":"CMAKE_MSVCIDE_RUN_PATH","trigger":"CMAKE_MSVCIDE_RUN_PATH\tbuiltin variable"},{"contents":"CMAKE_MSVC_RUNTIME_LIBRARY","trigger":"CMAKE_MSVC_RUNTIME_LIBRARY\tbuiltin variable"},{"contents":"CMAKE_NETRC","trigger":"CMAKE_NETRC\tbuiltin variable"},{"contents":"CMAKE_NETRC_FILE","trigger":"CMAKE_NETRC_FILE\tbuiltin variable"},{"contents":"CMAKE_NINJA_OUTPUT_PATH_PREFIX","trigger":"CMAKE_NINJA_OUTPUT_PATH_PREFIX\tbuiltin variable"},{"contents":"CMAKE_NOT_USING_CONFIG_FLAGS","trigger":"CMAKE_NOT_USING_CONFIG_FLAGS\tbuiltin variable"},{"contents":"CMAKE_NO_BUILTIN_CHRPATH","trigger":"CMAKE_NO_BUILTIN_CHRPATH\tbuiltin variable"},{"contents":"CMAKE_NO_SYSTEM_FROM_IMPORTED","trigger":"CMAKE_NO_SYSTEM_FROM_IMPORTED\tbuiltin variable"},{"contents":"CMAKE_OBJCXX_EXTENSIONS","trigger":"CMAKE_OBJCXX_EXTENSIONS\tbuiltin variable"},{"contents":"CMAKE_OBJCXX_STANDARD","trigger":"CMAKE_OBJCXX_STANDARD\tbuiltin variable"},{"contents":"CMAKE_OBJCXX_STANDARD_REQUIRED","trigger":"CMAKE_OBJCXX_STANDARD_REQUIRED\tbuiltin variable"},{"contents":"CMAKE_OBJC_EXTENSIONS","trigger":"CMAKE_OBJC_EXTENSIONS\tbuiltin variable"},{"contents":"CMAKE_OBJC_STANDARD","trigger":"CMAKE_OBJC_STANDARD\tbuiltin variable"},{"contents":"CMAKE_OBJC_STANDARD_REQUIRED","trigger":"CMAKE_OBJC_STANDARD_REQUIRED\tbuiltin variable"},{"contents":"CMAKE_OBJECT_PATH_MAX","trigger":"CMAKE_OBJECT_PATH_MAX\tbuiltin variable"},{"contents":"CMAKE_OPTIMIZE_DEPENDENCIES","trigger":"CMAKE_OPTIMIZE_DEPENDENCIES\tbuiltin variable"},{"contents":"CMAKE_OSX_ARCHITECTURES","trigger":"CMAKE_OSX_ARCHITECTURES\tbuiltin variable"},{"contents":"CMAKE_OSX_DEPLOYMENT_TARGET","trigger":"CMAKE_OSX_DEPLOYMENT_TARGET\tbuiltin variable"},{"contents":"CMAKE_OSX_SYSROOT","trigger":"CMAKE_OSX_SYSROOT\tbuiltin variable"},{"contents":"CMAKE_PARENT_LIST_FILE","trigger":"CMAKE_PARENT_LIST_FILE\tbuiltin variable"},{"contents":"CMAKE_PATCH_VERSION","trigger":"CMAKE_PATCH_VERSION\tbuiltin variable"},{"contents":"CMAKE_PCH_INSTANTIATE_TEMPLATES","trigger":"CMAKE_PCH_INSTANTIATE_TEMPLATES\tbuiltin variable"},{"contents":"CMAKE_PCH_WARN_INVALID","trigger":"CMAKE_PCH_WARN_INVALID\tbuiltin variable"},{"contents":"CMAKE_PDB_OUTPUT_DIRECTORY","trigger":"CMAKE_PDB_OUTPUT_DIRECTORY\tbuiltin variable"},{"contents":"CMAKE_POSITION_INDEPENDENT_CODE","trigger":"CMAKE_POSITION_INDEPENDENT_CODE\tbuiltin variable"},{"contents":"CMAKE_PREFIX_PATH","trigger":"CMAKE_PREFIX_PATH\tbuiltin variable"},{"contents":"CMAKE_PROGRAM_PATH","trigger":"CMAKE_PROGRAM_PATH\tbuiltin variable"},{"contents":"CMAKE_PROJECT_DESCRIPTION","trigger":"CMAKE_PROJECT_DESCRIPTION\tbuiltin variable"},{"contents":"CMAKE_PROJECT_HOMEPAGE_URL","trigger":"CMAKE_PROJECT_HOMEPAGE_URL\tbuiltin variable"},{"contents":"CMAKE_PROJECT_INCLUDE","trigger":"CMAKE_PROJECT_INCLUDE\tbuiltin variable"},{"contents":"CMAKE_PROJECT_INCLUDE_BEFORE","trigger":"CMAKE_PROJECT_INCLUDE_BEFORE\tbuiltin variable"},{"contents":"CMAKE_PROJECT_NAME","trigger":"CMAKE_PROJECT_NAME\tbuiltin variable"},{"contents":"CMAKE_PROJECT_VERSION","trigger":"CMAKE_PROJECT_VERSION\tbuiltin variable"},{"contents":"CMAKE_PROJECT_VERSION_MAJOR","trigger":"CMAKE_PROJECT_VERSION_MAJOR\tbuiltin variable"},{"contents":"CMAKE_PROJECT_VERSION_MINOR","trigger":"CMAKE_PROJECT_VERSION_MINOR\tbuiltin variable"},{"contents":"CMAKE_PROJECT_VERSION_PATCH","trigger":"CMAKE_PROJECT_VERSION_PATCH\tbuiltin variable"},{"contents":"CMAKE_PROJECT_VERSION_TWEAK","trigger":"CMAKE_PROJECT_VERSION_TWEAK\tbuiltin variable"},{"contents":"CMAKE_RANLIB","trigger":"CMAKE_RANLIB\tbuiltin variable"},{"contents":"CMAKE_ROOT","trigger":"CMAKE_ROOT\tbuiltin variable"},{"contents":"CMAKE_RULE_MESSAGES","trigger":"CMAKE_RULE_MESSAGES\tbuiltin variable"},{"contents":"CMAKE_RUNTIME_OUTPUT_DIRECTORY","trigger":"CMAKE_RUNTIME_OUTPUT_DIRECTORY\tbuiltin variable"},{"contents":"CMAKE_SCRIPT_MODE_FILE","trigger":"CMAKE_SCRIPT_MODE_FILE\tbuiltin variable"},{"contents":"CMAKE_SHARED_LIBRARY_PREFIX","trigger":"CMAKE_SHARED_LIBRARY_PREFIX\tbuiltin variable"},{"contents":"CMAKE_SHARED_LIBRARY_SUFFIX","trigger":"CMAKE_SHARED_LIBRARY_SUFFIX\tbuiltin variable"},{"contents":"CMAKE_SHARED_LINKER_FLAGS","trigger":"CMAKE_SHARED_LINKER_FLAGS\tbuiltin variable"},{"contents":"CMAKE_SHARED_LINKER_FLAGS_INIT","trigger":"CMAKE_SHARED_LINKER_FLAGS_INIT\tbuiltin variable"},{"contents":"CMAKE_SHARED_MODULE_PREFIX","trigger":"CMAKE_SHARED_MODULE_PREFIX\tbuiltin variable"},{"contents":"CMAKE_SHARED_MODULE_SUFFIX","trigger":"CMAKE_SHARED_MODULE_SUFFIX\tbuiltin variable"},{"contents":"CMAKE_SIZEOF_VOID_P","trigger":"CMAKE_SIZEOF_VOID_P\tbuiltin variable"},{"contents":"CMAKE_SKIP_BUILD_RPATH","trigger":"CMAKE_SKIP_BUILD_RPATH\tbuiltin variable"},{"contents":"CMAKE_SKIP_INSTALL_ALL_DEPENDENCY","trigger":"CMAKE_SKIP_INSTALL_ALL_DEPENDENCY\tbuiltin variable"},{"contents":"CMAKE_SKIP_INSTALL_RPATH","trigger":"CMAKE_SKIP_INSTALL_RPATH\tbuiltin variable"},{"contents":"CMAKE_SKIP_INSTALL_RULES","trigger":"CMAKE_SKIP_INSTALL_RULES\tbuiltin variable"},{"contents":"CMAKE_SKIP_RPATH","trigger":"CMAKE_SKIP_RPATH\tbuiltin variable"},{"contents":"CMAKE_SOURCE_DIR","trigger":"CMAKE_SOURCE_DIR\tbuiltin variable"},{"contents":"CMAKE_STAGING_PREFIX","trigger":"CMAKE_STAGING_PREFIX\tbuiltin variable"},{"contents":"CMAKE_STATIC_LIBRARY_PREFIX","trigger":"CMAKE_STATIC_LIBRARY_PREFIX\tbuiltin variable"},{"contents":"CMAKE_STATIC_LIBRARY_SUFFIX","trigger":"CMAKE_STATIC_LIBRARY_SUFFIX\tbuiltin variable"},{"contents":"CMAKE_STATIC_LINKER_FLAGS","trigger":"CMAKE_STATIC_LINKER_FLAGS\tbuiltin variable"},{"contents":"CMAKE_STATIC_LINKER_FLAGS_INIT","trigger":"CMAKE_STATIC_LINKER_FLAGS_INIT\tbuiltin variable"},{"contents":"CMAKE_SUBLIME_TEXT_2_ENV_SETTINGS","trigger":"CMAKE_SUBLIME_TEXT_2_ENV_SETTINGS\tbuiltin variable"},{"contents":"CMAKE_SUBLIME_TEXT_2_EXCLUDE_BUILD_TREE","trigger":"CMAKE_SUBLIME_TEXT_2_EXCLUDE_BUILD_TREE\tbuiltin variable"},{"contents":"CMAKE_SUPPRESS_REGENERATION","trigger":"CMAKE_SUPPRESS_REGENERATION\tbuiltin variable"},{"contents":"CMAKE_SYSROOT","trigger":"CMAKE_SYSROOT\tbuiltin variable"},{"contents":"CMAKE_SYSROOT_COMPILE","trigger":"CMAKE_SYSROOT_COMPILE\tbuiltin variable"},{"contents":"CMAKE_SYSROOT_LINK","trigger":"CMAKE_SYSROOT_LINK\tbuiltin variable"},{"contents":"CMAKE_SYSTEM","trigger":"CMAKE_SYSTEM\tbuiltin variable"},{"contents":"CMAKE_SYSTEM_APPBUNDLE_PATH","trigger":"CMAKE_SYSTEM_APPBUNDLE_PATH\tbuiltin variable"},{"contents":"CMAKE_SYSTEM_FRAMEWORK_PATH","trigger":"CMAKE_SYSTEM_FRAMEWORK_PATH\tbuiltin variable"},{"contents":"CMAKE_SYSTEM_IGNORE_PATH","trigger":"CMAKE_SYSTEM_IGNORE_PATH\tbuiltin variable"},{"contents":"CMAKE_SYSTEM_INCLUDE_PATH","trigger":"CMAKE_SYSTEM_INCLUDE_PATH\tbuiltin variable"},{"contents":"CMAKE_SYSTEM_LIBRARY_PATH","trigger":"CMAKE_SYSTEM_LIBRARY_PATH\tbuiltin variable"},{"contents":"CMAKE_SYSTEM_NAME","trigger":"CMAKE_SYSTEM_NAME\tbuiltin variable"},{"contents":"CMAKE_SYSTEM_PREFIX_PATH","trigger":"CMAKE_SYSTEM_PREFIX_PATH\tbuiltin variable"},{"contents":"CMAKE_SYSTEM_PROCESSOR","trigger":"CMAKE_SYSTEM_PROCESSOR\tbuiltin variable"},{"contents":"CMAKE_SYSTEM_PROGRAM_PATH","trigger":"CMAKE_SYSTEM_PROGRAM_PATH\tbuiltin variable"},{"contents":"CMAKE_SYSTEM_VERSION","trigger":"CMAKE_SYSTEM_VERSION\tbuiltin variable"},{"contents":"CMAKE_Swift_LANGUAGE_VERSION","trigger":"CMAKE_Swift_LANGUAGE_VERSION\tbuiltin variable"},{"contents":"CMAKE_Swift_MODULE_DIRECTORY","trigger":"CMAKE_Swift_MODULE_DIRECTORY\tbuiltin variable"},{"contents":"CMAKE_Swift_NUM_THREADS","trigger":"CMAKE_Swift_NUM_THREADS\tbuiltin variable"},{"contents":"CMAKE_TOOLCHAIN_FILE","trigger":"CMAKE_TOOLCHAIN_FILE\tbuiltin variable"},{"contents":"CMAKE_TRY_COMPILE_CONFIGURATION","trigger":"CMAKE_TRY_COMPILE_CONFIGURATION\tbuiltin variable"},{"contents":"CMAKE_TRY_COMPILE_PLATFORM_VARIABLES","trigger":"CMAKE_TRY_COMPILE_PLATFORM_VARIABLES\tbuiltin variable"},{"contents":"CMAKE_TRY_COMPILE_TARGET_TYPE","trigger":"CMAKE_TRY_COMPILE_TARGET_TYPE\tbuiltin variable"},{"contents":"CMAKE_TWEAK_VERSION","trigger":"CMAKE_TWEAK_VERSION\tbuiltin variable"},{"contents":"CMAKE_UNITY_BUILD","trigger":"CMAKE_UNITY_BUILD\tbuiltin variable"},{"contents":"CMAKE_UNITY_BUILD_[1;33m[KBAT[m[KCH_SIZE","trigger":"CMAKE_UNITY_BUILD_[1;33m[KBAT[m[KCH_SIZE\tbuiltin variable"},{"contents":"CMAKE_USER_MAKE_RULES_OVERRIDE","trigger":"CMAKE_USER_MAKE_RULES_OVERRIDE\tbuiltin variable"},{"contents":"CMAKE_USE_RELATIVE_PATHS","trigger":"CMAKE_USE_RELATIVE_PATHS\tbuiltin variable"},{"contents":"CMAKE_VERBOSE_MAKEFILE","trigger":"CMAKE_VERBOSE_MAKEFILE\tbuiltin variable"},{"contents":"CMAKE_VERSION","trigger":"CMAKE_VERSION\tbuiltin variable"},{"contents":"CMAKE_VISIBILITY_INLINES_HIDDEN","trigger":"CMAKE_VISIBILITY_INLINES_HIDDEN\tbuiltin variable"},{"contents":"CMAKE_VS_DEVENV_COMMAND","trigger":"CMAKE_VS_DEVENV_COMMAND\tbuiltin variable"},{"contents":"CMAKE_VS_GLOBALS","trigger":"CMAKE_VS_GLOBALS\tbuiltin variable"},{"contents":"CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD","trigger":"CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD\tbuiltin variable"},{"contents":"CMAKE_VS_INCLUDE_PACKAGE_TO_DEFAULT_BUILD","trigger":"CMAKE_VS_INCLUDE_PACKAGE_TO_DEFAULT_BUILD\tbuiltin variable"},{"contents":"CMAKE_VS_INTEL_Fortran_PROJECT_VERSION","trigger":"CMAKE_VS_INTEL_Fortran_PROJECT_VERSION\tbuiltin variable"},{"contents":"CMAKE_VS_JUST_MY_CODE_DEBUGGING","trigger":"CMAKE_VS_JUST_MY_CODE_DEBUGGING\tbuiltin variable"},{"contents":"CMAKE_VS_MSBUILD_COMMAND","trigger":"CMAKE_VS_MSBUILD_COMMAND\tbuiltin variable"},{"contents":"CMAKE_VS_NsightTegra_VERSION","trigger":"CMAKE_VS_NsightTegra_VERSION\tbuiltin variable"},{"contents":"CMAKE_VS_PLATFORM_NAME","trigger":"CMAKE_VS_PLATFORM_NAME\tbuiltin variable"},{"contents":"CMAKE_VS_PLATFORM_NAME_DEFAULT","trigger":"CMAKE_VS_PLATFORM_NAME_DEFAULT\tbuiltin variable"},{"contents":"CMAKE_VS_PLATFORM_TOOLSET","trigger":"CMAKE_VS_PLATFORM_TOOLSET\tbuiltin variable"},{"contents":"CMAKE_VS_PLATFORM_TOOLSET_CUDA","trigger":"CMAKE_VS_PLATFORM_TOOLSET_CUDA\tbuiltin variable"},{"contents":"CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR","trigger":"CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR\tbuiltin variable"},{"contents":"CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE","trigger":"CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE\tbuiltin variable"},{"contents":"CMAKE_VS_PLATFORM_TOOLSET_VERSION","trigger":"CMAKE_VS_PLATFORM_TOOLSET_VERSION\tbuiltin variable"},{"contents":"CMAKE_VS_SDK_EXCLUDE_DIRECTORIES","trigger":"CMAKE_VS_SDK_EXCLUDE_DIRECTORIES\tbuiltin variable"},{"contents":"CMAKE_VS_SDK_EXECUTABLE_DIRECTORIES","trigger":"CMAKE_VS_SDK_EXECUTABLE_DIRECTORIES\tbuiltin variable"},{"contents":"CMAKE_VS_SDK_INCLUDE_DIRECTORIES","trigger":"CMAKE_VS_SDK_INCLUDE_DIRECTORIES\tbuiltin variable"},{"contents":"CMAKE_VS_SDK_LIBRARY_DIRECTORIES","trigger":"CMAKE_VS_SDK_LIBRARY_DIRECTORIES\tbuiltin variable"},{"contents":"CMAKE_VS_SDK_LIBRARY_WINRT_DIRECTORIES","trigger":"CMAKE_VS_SDK_LIBRARY_WINRT_DIRECTORIES\tbuiltin variable"},{"contents":"CMAKE_VS_SDK_REFERENCE_DIRECTORIES","trigger":"CMAKE_VS_SDK_REFERENCE_DIRECTORIES\tbuiltin variable"},{"contents":"CMAKE_VS_SDK_SOURCE_DIRECTORIES","trigger":"CMAKE_VS_SDK_SOURCE_DIRECTORIES\tbuiltin variable"},{"contents":"CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION","trigger":"CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION\tbuiltin variable"},{"contents":"CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION_MAXIMUM","trigger":"CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION_MAXIMUM\tbuiltin variable"},{"contents":"CMAKE_VS_WINRT_BY_DEFAULT","trigger":"CMAKE_VS_WINRT_BY_DEFAULT\tbuiltin variable"},{"contents":"CMAKE_WARN_DEPRECATED","trigger":"CMAKE_WARN_DEPRECATED\tbuiltin variable"},{"contents":"CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION","trigger":"CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION\tbuiltin variable"},{"contents":"CMAKE_WIN32_EXECUTABLE","trigger":"CMAKE_WIN32_EXECUTABLE\tbuiltin variable"},{"contents":"CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS","trigger":"CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS\tbuiltin variable"},{"contents":"CMAKE_XCODE_BUILD_SYSTEM","trigger":"CMAKE_XCODE_BUILD_SYSTEM\tbuiltin variable"},{"contents":"CMAKE_XCODE_GENERATE_SCHEME","trigger":"CMAKE_XCODE_GENERATE_SCHEME\tbuiltin variable"},{"contents":"CMAKE_XCODE_GENERATE_TOP_LEVEL_PROJECT_ONLY","trigger":"CMAKE_XCODE_GENERATE_TOP_LEVEL_PROJECT_ONLY\tbuiltin variable"},{"contents":"CMAKE_XCODE_LINK_BUILD_PHASE_MODE","trigger":"CMAKE_XCODE_LINK_BUILD_PHASE_MODE\tbuiltin variable"},{"contents":"CMAKE_XCODE_PLATFORM_TOOLSET","trigger":"CMAKE_XCODE_PLATFORM_TOOLSET\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_ADDRESS_SANITIZER","trigger":"CMAKE_XCODE_SCHEME_ADDRESS_SANITIZER\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_ADDRESS_SANITIZER_USE_AFTER_RETURN","trigger":"CMAKE_XCODE_SCHEME_ADDRESS_SANITIZER_USE_AFTER_RETURN\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_DEBUG_DOCUMENT_VERSIONING","trigger":"CMAKE_XCODE_SCHEME_DEBUG_DOCUMENT_VERSIONING\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_DISABLE_MAIN_THREAD_CHECKER","trigger":"CMAKE_XCODE_SCHEME_DISABLE_MAIN_THREAD_CHECKER\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_DYNAMIC_LIBRARY_LOADS","trigger":"CMAKE_XCODE_SCHEME_DYNAMIC_LIBRARY_LOADS\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_DYNAMIC_LINKER_API_USAGE","trigger":"CMAKE_XCODE_SCHEME_DYNAMIC_LINKER_API_USAGE\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_ENVIRONMENT","trigger":"CMAKE_XCODE_SCHEME_ENVIRONMENT\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_GUARD_MALLOC","trigger":"CMAKE_XCODE_SCHEME_GUARD_MALLOC\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_MAIN_THREAD_CHECKER_STOP","trigger":"CMAKE_XCODE_SCHEME_MAIN_THREAD_CHECKER_STOP\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_MALLOC_GUARD_EDGES","trigger":"CMAKE_XCODE_SCHEME_MALLOC_GUARD_EDGES\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_MALLOC_SCRIBBLE","trigger":"CMAKE_XCODE_SCHEME_MALLOC_SCRIBBLE\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_MALLOC_STACK","trigger":"CMAKE_XCODE_SCHEME_MALLOC_STACK\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_THREAD_SANITIZER","trigger":"CMAKE_XCODE_SCHEME_THREAD_SANITIZER\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_THREAD_SANITIZER_STOP","trigger":"CMAKE_XCODE_SCHEME_THREAD_SANITIZER_STOP\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER","trigger":"CMAKE_XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER_STOP","trigger":"CMAKE_XCODE_SCHEME_UNDEFINED_BEHAVIOUR_SANITIZER_STOP\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_WORKING_DIRECTORY","trigger":"CMAKE_XCODE_SCHEME_WORKING_DIRECTORY\tbuiltin variable"},{"contents":"CMAKE_XCODE_SCHEME_ZOMBIE_OBJECTS","trigger":"CMAKE_XCODE_SCHEME_ZOMBIE_OBJECTS\tbuiltin variable"},{"contents":"CPACK_ABSOLUTE_DESTINATION_FILES","trigger":"CPACK_ABSOLUTE_DESTINATION_FILES\tbuiltin variable"},{"contents":"CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY","trigger":"CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY\tbuiltin variable"},{"contents":"CPACK_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION","trigger":"CPACK_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION\tbuiltin variable"},{"contents":"CPACK_INCLUDE_TOPLEVEL_DIRECTORY","trigger":"CPACK_INCLUDE_TOPLEVEL_DIRECTORY\tbuiltin variable"},{"contents":"CPACK_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS","trigger":"CPACK_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS\tbuiltin variable"},{"contents":"CPACK_PACKAGING_INSTALL_PREFIX","trigger":"CPACK_PACKAGING_INSTALL_PREFIX\tbuiltin variable"},{"contents":"CPACK_SET_DESTDIR","trigger":"CPACK_SET_DESTDIR\tbuiltin variable"},{"contents":"CPACK_WARN_ON_ABSOLUTE_INSTALL_DESTINATION","trigger":"CPACK_WARN_ON_ABSOLUTE_INSTALL_DESTINATION\tbuiltin variable"},{"contents":"CTEST_BINARY_DIRECTORY","trigger":"CTEST_BINARY_DIRECTORY\tbuiltin variable"},{"contents":"CTEST_BUILD_COMMAND","trigger":"CTEST_BUILD_COMMAND\tbuiltin variable"},{"contents":"CTEST_BUILD_NAME","trigger":"CTEST_BUILD_NAME\tbuiltin variable"},{"contents":"CTEST_BZR_COMMAND","trigger":"CTEST_BZR_COMMAND\tbuiltin variable"},{"contents":"CTEST_BZR_UPDATE_OPTIONS","trigger":"CTEST_BZR_UPDATE_OPTIONS\tbuiltin variable"},{"contents":"CTEST_CHANGE_ID","trigger":"CTEST_CHANGE_ID\tbuiltin variable"},{"contents":"CTEST_CHECKOUT_COMMAND","trigger":"CTEST_CHECKOUT_COMMAND\tbuiltin variable"},{"contents":"CTEST_CONFIGURATION_TYPE","trigger":"CTEST_CONFIGURATION_TYPE\tbuiltin variable"},{"contents":"CTEST_CONFIGURE_COMMAND","trigger":"CTEST_CONFIGURE_COMMAND\tbuiltin variable"},{"contents":"CTEST_COVERAGE_COMMAND","trigger":"CTEST_COVERAGE_COMMAND\tbuiltin variable"},{"contents":"CTEST_COVERAGE_EXTRA_FLAGS","trigger":"CTEST_COVERAGE_EXTRA_FLAGS\tbuiltin variable"},{"contents":"CTEST_CURL_OPTIONS","trigger":"CTEST_CURL_OPTIONS\tbuiltin variable"},{"contents":"CTEST_CUSTOM_COVERAGE_EXCLUDE","trigger":"CTEST_CUSTOM_COVERAGE_EXCLUDE\tbuiltin variable"},{"contents":"CTEST_CUSTOM_ERROR_EXCEPTION","trigger":"CTEST_CUSTOM_ERROR_EXCEPTION\tbuiltin variable"},{"contents":"CTEST_CUSTOM_ERROR_MATCH","trigger":"CTEST_CUSTOM_ERROR_MATCH\tbuiltin variable"},{"contents":"CTEST_CUSTOM_ERROR_POST_CONTEXT","trigger":"CTEST_CUSTOM_ERROR_POST_CONTEXT\tbuiltin variable"},{"contents":"CTEST_CUSTOM_ERROR_PRE_CONTEXT","trigger":"CTEST_CUSTOM_ERROR_PRE_CONTEXT\tbuiltin variable"},{"contents":"CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE","trigger":"CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE\tbuiltin variable"},{"contents":"CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS","trigger":"CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS\tbuiltin variable"},{"contents":"CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS","trigger":"CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS\tbuiltin variable"},{"contents":"CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE","trigger":"CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE\tbuiltin variable"},{"contents":"CTEST_CUSTOM_MEMCHECK_IGNORE","trigger":"CTEST_CUSTOM_MEMCHECK_IGNORE\tbuiltin variable"},{"contents":"CTEST_CUSTOM_POST_MEMCHECK","trigger":"CTEST_CUSTOM_POST_MEMCHECK\tbuiltin variable"},{"contents":"CTEST_CUSTOM_POST_TEST","trigger":"CTEST_CUSTOM_POST_TEST\tbuiltin variable"},{"contents":"CTEST_CUSTOM_PRE_MEMCHECK","trigger":"CTEST_CUSTOM_PRE_MEMCHECK\tbuiltin variable"},{"contents":"CTEST_CUSTOM_PRE_TEST","trigger":"CTEST_CUSTOM_PRE_TEST\tbuiltin variable"},{"contents":"CTEST_CUSTOM_TESTS_IGNORE","trigger":"CTEST_CUSTOM_TESTS_IGNORE\tbuiltin variable"},{"contents":"CTEST_CUSTOM_WARNING_EXCEPTION","trigger":"CTEST_CUSTOM_WARNING_EXCEPTION\tbuiltin variable"},{"contents":"CTEST_CUSTOM_WARNING_MATCH","trigger":"CTEST_CUSTOM_WARNING_MATCH\tbuiltin variable"},{"contents":"CTEST_CVS_CHECKOUT","trigger":"CTEST_CVS_CHECKOUT\tbuiltin variable"},{"contents":"CTEST_CVS_COMMAND","trigger":"CTEST_CVS_COMMAND\tbuiltin variable"},{"contents":"CTEST_CVS_UPDATE_OPTIONS","trigger":"CTEST_CVS_UPDATE_OPTIONS\tbuiltin variable"},{"contents":"CTEST_DROP_LOCATION","trigger":"CTEST_DROP_LOCATION\tbuiltin variable"},{"contents":"CTEST_DROP_METHOD","trigger":"CTEST_DROP_METHOD\tbuiltin variable"},{"contents":"CTEST_DROP_SITE","trigger":"CTEST_DROP_SITE\tbuiltin variable"},{"contents":"CTEST_DROP_SITE_CDASH","trigger":"CTEST_DROP_SITE_CDASH\tbuiltin variable"},{"contents":"CTEST_DROP_SITE_PASSWORD","trigger":"CTEST_DROP_SITE_PASSWORD\tbuiltin variable"},{"contents":"CTEST_DROP_SITE_USER","trigger":"CTEST_DROP_SITE_USER\tbuiltin variable"},{"contents":"CTEST_EXTRA_COVERAGE_GLOB","trigger":"CTEST_EXTRA_COVERAGE_GLOB\tbuiltin variable"},{"contents":"CTEST_GIT_COMMAND","trigger":"CTEST_GIT_COMMAND\tbuiltin variable"},{"contents":"CTEST_GIT_INIT_SUBMODULES","trigger":"CTEST_GIT_INIT_SUBMODULES\tbuiltin variable"},{"contents":"CTEST_GIT_UPDATE_CUSTOM","trigger":"CTEST_GIT_UPDATE_CUSTOM\tbuiltin variable"},{"contents":"CTEST_GIT_UPDATE_OPTIONS","trigger":"CTEST_GIT_UPDATE_OPTIONS\tbuiltin variable"},{"contents":"CTEST_HG_COMMAND","trigger":"CTEST_HG_COMMAND\tbuiltin variable"},{"contents":"CTEST_HG_UPDATE_OPTIONS","trigger":"CTEST_HG_UPDATE_OPTIONS\tbuiltin variable"},{"contents":"CTEST_LABELS_FOR_SUBPROJECTS","trigger":"CTEST_LABELS_FOR_SUBPROJECTS\tbuiltin variable"},{"contents":"CTEST_MEMORYCHECK_COMMAND","trigger":"CTEST_MEMORYCHECK_COMMAND\tbuiltin variable"},{"contents":"CTEST_MEMORYCHECK_COMMAND_OPTIONS","trigger":"CTEST_MEMORYCHECK_COMMAND_OPTIONS\tbuiltin variable"},{"contents":"CTEST_MEMORYCHECK_SANITIZER_OPTIONS","trigger":"CTEST_MEMORYCHECK_SANITIZER_OPTIONS\tbuiltin variable"},{"contents":"CTEST_MEMORYCHECK_SUPPRESSIONS_FILE","trigger":"CTEST_MEMORYCHECK_SUPPRESSIONS_FILE\tbuiltin variable"},{"contents":"CTEST_MEMORYCHECK_TYPE","trigger":"CTEST_MEMORYCHECK_TYPE\tbuiltin variable"},{"contents":"CTEST_NIGHTLY_START_TIME","trigger":"CTEST_NIGHTLY_START_TIME\tbuiltin variable"},{"contents":"CTEST_P4_CLIENT","trigger":"CTEST_P4_CLIENT\tbuiltin variable"},{"contents":"CTEST_P4_COMMAND","trigger":"CTEST_P4_COMMAND\tbuiltin variable"},{"contents":"CTEST_P4_OPTIONS","trigger":"CTEST_P4_OPTIONS\tbuiltin variable"},{"contents":"CTEST_P4_UPDATE_OPTIONS","trigger":"CTEST_P4_UPDATE_OPTIONS\tbuiltin variable"},{"contents":"CTEST_RESOURCE_SPEC_FILE","trigger":"CTEST_RESOURCE_SPEC_FILE\tbuiltin variable"},{"contents":"CTEST_RUN_CURRENT_SCRIPT","trigger":"CTEST_RUN_CURRENT_SCRIPT\tbuiltin variable"},{"contents":"CTEST_SCP_COMMAND","trigger":"CTEST_SCP_COMMAND\tbuiltin variable"},{"contents":"CTEST_SITE","trigger":"CTEST_SITE\tbuiltin variable"},{"contents":"CTEST_SOURCE_DIRECTORY","trigger":"CTEST_SOURCE_DIRECTORY\tbuiltin variable"},{"contents":"CTEST_SUBMIT_URL","trigger":"CTEST_SUBMIT_URL\tbuiltin variable"},{"contents":"CTEST_SVN_COMMAND","trigger":"CTEST_SVN_COMMAND\tbuiltin variable"},{"contents":"CTEST_SVN_OPTIONS","trigger":"CTEST_SVN_OPTIONS\tbuiltin variable"},{"contents":"CTEST_SVN_UPDATE_OPTIONS","trigger":"CTEST_SVN_UPDATE_OPTIONS\tbuiltin variable"},{"contents":"CTEST_TEST_LOAD","trigger":"CTEST_TEST_LOAD\tbuiltin variable"},{"contents":"CTEST_TEST_TIMEOUT","trigger":"CTEST_TEST_TIMEOUT\tbuiltin variable"},{"contents":"CTEST_TRIGGER_SITE","trigger":"CTEST_TRIGGER_SITE\tbuiltin variable"},{"contents":"CTEST_UPDATE_COMMAND","trigger":"CTEST_UPDATE_COMMAND\tbuiltin variable"},{"contents":"CTEST_UPDATE_OPTIONS","trigger":"CTEST_UPDATE_OPTIONS\tbuiltin variable"},{"contents":"CTEST_UPDATE_VERSION_ONLY","trigger":"CTEST_UPDATE_VERSION_ONLY\tbuiltin variable"},{"contents":"CTEST_UPDATE_VERSION_OVERRIDE","trigger":"CTEST_UPDATE_VERSION_OVERRIDE\tbuiltin variable"},{"contents":"CTEST_USE_LAUNCHERS","trigger":"CTEST_USE_LAUNCHERS\tbuiltin variable"},{"contents":"CYGWIN","trigger":"CYGWIN\tbuiltin variable"},{"contents":"ENV","trigger":"ENV\tbuiltin variable"},{"contents":"EXECUTABLE_OUTPUT_PATH","trigger":"EXECUTABLE_OUTPUT_PATH\tbuiltin variable"},{"contents":"GHS-MULTI","trigger":"GHS-MULTI\tbuiltin variable"},{"contents":"IOS","trigger":"IOS\tbuiltin variable"},{"contents":"LIBRARY_OUTPUT_PATH","trigger":"LIBRARY_OUTPUT_PATH\tbuiltin variable"},{"contents":"MINGW","trigger":"MINGW\tbuiltin variable"},{"contents":"MSVC","trigger":"MSVC\tbuiltin variable"},{"contents":"MSVC10","trigger":"MSVC10\tbuiltin variable"},{"contents":"MSVC11","trigger":"MSVC11\tbuiltin variable"},{"contents":"MSVC12","trigger":"MSVC12\tbuiltin variable"},{"contents":"MSVC14","trigger":"MSVC14\tbuiltin variable"},{"contents":"MSVC60","trigger":"MSVC60\tbuiltin variable"},{"contents":"MSVC70","trigger":"MSVC70\tbuiltin variable"},{"contents":"MSVC71","trigger":"MSVC71\tbuiltin variable"},{"contents":"MSVC80","trigger":"MSVC80\tbuiltin variable"},{"contents":"MSVC90","trigger":"MSVC90\tbuiltin variable"},{"contents":"MSVC_IDE","trigger":"MSVC_IDE\tbuiltin variable"},{"contents":"MSVC_TOOLSET_VERSION","trigger":"MSVC_TOOLSET_VERSION\tbuiltin variable"},{"contents":"MSVC_VERSION","trigger":"MSVC_VERSION\tbuiltin variable"},{"contents":"MSYS","trigger":"MSYS\tbuiltin variable"},{"contents":"PROJECT_BINARY_DIR","trigger":"PROJECT_BINARY_DIR\tbuiltin variable"},{"contents":"PROJECT_DESCRIPTION","trigger":"PROJECT_DESCRIPTION\tbuiltin variable"},{"contents":"PROJECT_HOMEPAGE_URL","trigger":"PROJECT_HOMEPAGE_URL\tbuiltin variable"},{"contents":"PROJECT_NAME","trigger":"PROJECT_NAME\tbuiltin variable"},{"contents":"PROJECT_SOURCE_DIR","trigger":"PROJECT_SOURCE_DIR\tbuiltin variable"},{"contents":"PROJECT_VERSION","trigger":"PROJECT_VERSION\tbuiltin variable"},{"contents":"PROJECT_VERSION_MAJOR","trigger":"PROJECT_VERSION_MAJOR\tbuiltin variable"},{"contents":"PROJECT_VERSION_MINOR","trigger":"PROJECT_VERSION_MINOR\tbuiltin variable"},{"contents":"PROJECT_VERSION_PATCH","trigger":"PROJECT_VERSION_PATCH\tbuiltin variable"},{"contents":"PROJECT_VERSION_TWEAK","trigger":"PROJECT_VERSION_TWEAK\tbuiltin variable"},{"contents":"UNIX","trigger":"UNIX\tbuiltin variable"},{"contents":"WIN32","trigger":"WIN32\tbuiltin variable"},{"contents":"WINCE","trigger":"WINCE\tbuiltin variable"},{"contents":"WINDOWS_PHONE","trigger":"WINDOWS_PHONE\tbuiltin variable"},{"contents":"WINDOWS_STORE","trigger":"WINDOWS_STORE\tbuiltin variable"},{"contents":"XCODE","trigger":"XCODE\tbuiltin variable"},{"contents":"XCODE_VERSION","trigger":"XCODE_VERSION\tbuiltin variable"}],"scope":"variable.other.readwrite.cmake"}

1194+[35m[Kassets/syntaxes/02_Extra/CMake/CMakeCommands.sublime-syntax[m[K[36m[K:[m[K[32m[K30[m[K[36m[K:[m[K - match: \bVER[1;33m[KBAT[m[KIM\b

1195+[35m[Kassets/syntaxes/02_Extra/CMake/CMakeCommands.sublime-syntax[m[K[36m[K:[m[K[32m[K31[m[K[36m[K:[m[K scope: variable.parameter.VER[1;33m[KBAT[m[KIM.cmake

1196+[35m[Kassets/syntaxes/02_Extra/CMake/CMakeCommands.sublime-syntax[m[K[36m[K:[m[K[32m[K59[m[K[36m[K:[m[K - match: \bVER[1;33m[KBAT[m[KIM\b

1197+[35m[Kassets/syntaxes/02_Extra/CMake/CMakeCommands.sublime-syntax[m[K[36m[K:[m[K[32m[K60[m[K[36m[K:[m[K scope: variable.parameter.VER[1;33m[KBAT[m[KIM.cmake

1198+[35m[Kassets/syntaxes/02_Extra/SCSS_Sass/Syntaxes/Sass.sublime-syntax[m[K[36m[K:[m[K[32m[K1830[m[K[36m[K:[m[K - match: '\[1;33m[Kbat[m[K\b'

1199+[35m[Kassets/syntaxes/02_Extra/Elixir/builds/Elixir - mix format $file.sublime-build[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K "cmd": ["mix.[1;33m[Kbat[m[K", "format", "$file", "--dot-formatter", "$folder/.formatter.exs"],

1200+[35m[Kassets/syntaxes/02_Extra/Elixir/builds/Elixir - elixir $file.sublime-build[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K "cmd": ["elixir.[1;33m[Kbat[m[K", "$file_name"]

1201+[35m[Kassets/syntaxes/02_Extra/Lean.sublime-syntax[m[K[36m[K:[m[K[32m[K23[m[K[36m[K:[m[K - match: '\[1;33m[Kbat[m[Ktribute\b\s*\[[^\]]*\]'

1202+[35m[Kassets/syntaxes/02_Extra/PowerShell.sublime-syntax[m[K[36m[K:[m[K[32m[K86[m[K[36m[K:[m[K - match: '(\b(([A-Za-z0-9\-_\.]+)\.(?i:exe|com|cmd|[1;33m[Kbat[m[K))\b)'

1203+[35m[Kassets/syntaxes/02_Extra/PowerShell.sublime-syntax[m[K[36m[K:[m[K[32m[K174[m[K[36m[K:[m[K - match: '(?:(\p{L}|\d|_|-|\\|\:)*\\)?\b(?i:Add|Approve|Assert|Backup|Block|Build|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy|Debug|Deny|Deploy|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|Format|Get|Grant|Group|Hide|Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Mount|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push|Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke|Save|Search|Select|Send|Set|Show|Skip|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Test|Trace|Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Write)\-.+?(?:\.(?i:exe|cmd|[1;33m[Kbat[m[K|ps1))?\b'

1204+[35m[Kassets/syntaxes/02_Extra/MediaWiki/MediawikiNG.sublime-syntax[m[K[36m[K:[m[K[32m[K129[m[K[36m[K:[m[K - meta_content_scope: meta.environment.embedded.dos[1;33m[Kbat[m[Kch.mediawiki source.dos[1;33m[Kbat[m[Kch.embedded

1205+[35m[Kassets/syntaxes/02_Extra/MediaWiki/MediawikiNG.sublime-syntax[m[K[36m[K:[m[K[32m[K132[m[K[36m[K:[m[K - include: scope:source.dos[1;33m[Kbat[m[Kch

1206+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.lin.x64/Crypto/Util/RFC1751.py[m[K[36m[K:[m[K[32m[K125[m[K[36m[K:[m[K "BAN", "BAR", "[1;33m[KBAT[m[K", "BAY", "BE", "BED", "BEE", "BEG", "BEN", "BET",

1207+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.lin.x64/Crypto/Util/RFC1751.py[m[K[36m[K:[m[K[32m[K189[m[K[36m[K:[m[K "BARN", "BARR", "BASE", "BASH", "BASK", "BASS", "[1;33m[KBAT[m[KE", "[1;33m[KBAT[m[KH",

1208+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.lin.x64/Crypto/SelfTest/Signature/test_vectors/wycheproof/ecdsa_test.json[m[K[36m[K:[m[K[32m[K12177[m[K[36m[K:[m[K "keyPem" : "-----BEGIN PUBLIC KEY-----\nMGowFAYHKoZIzj0CAQYJKyQDAwIIAQEJA1IABHJlM+Jnc6xyChF[1;33m[KbAt[m[K6JrBWWZnfi\nObfFd6HBW4ECex/rc+ZzYB4hGqkqzLWFvAbMJ0thyeYUdG7dJI0czPjYsatLwVzF\njN8RYGXOl2fyoyI9\n-----END PUBLIC KEY-----",

1209+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.lin.x64/Crypto/SelfTest/Signature/test_vectors/wycheproof/ecdsa_test.json[m[K[36m[K:[m[K[32m[K13141[m[K[36m[K:[m[K "keyPem" : "-----BEGIN PUBLIC KEY-----\nMHowFAYHKoZIzj0CAQYJKyQDAwIIAQELA2IA[1;33m[KBAT[m[KZ1KYtbrAgc+c4seQ5zs1UQAMZ\nEfRRkOtgYqM1NfxSabz8JdSvwdrg662UjXcy2AKa836Jo86n3ziwIPYkkG/KbZRO\nFIaFP+jlupz7otdKhS7Fh9Rv5JkXw2RBjvfspQ==\n-----END PUBLIC KEY-----",

1210+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.lin.x64/Crypto/SelfTest/Signature/test_vectors/wycheproof/ecdsa_secp256r1_sha256_test.json[m[K[36m[K:[m[K[32m[K2410[m[K[36m[K:[m[K "keyPem" : "-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3q0Rx6WzloYvIZdNxHUvre/5lO/p\nu9[1;33m[KBat[m[KBN2XqgLbh8d4/BkDorG7c+Jz/U8QOJlu5QHijQ3Nt8HqgMY/H/h/w==\n-----END PUBLIC KEY-----",

1211+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.lin.x64/Crypto/SelfTest/PublicKey/test_import_RSA.py[m[K[36m[K:[m[K[32m[K444[m[K[36m[K:[m[KMIIEcjCCAlqgAwIBAgI[1;33m[KBAT[m[KANBgkqhkiG9w0BAQsFADBhMQswCQYDVQQGEwJVUzEL

1212+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.win.x64/Crypto/Util/RFC1751.py[m[K[36m[K:[m[K[32m[K125[m[K[36m[K:[m[K "BAN", "BAR", "[1;33m[KBAT[m[K", "BAY", "BE", "BED", "BEE", "BEG", "BEN", "BET",

1213+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.win.x64/Crypto/Util/RFC1751.py[m[K[36m[K:[m[K[32m[K189[m[K[36m[K:[m[K "BARN", "BARR", "BASE", "BASH", "BASK", "BASS", "[1;33m[KBAT[m[KE", "[1;33m[KBAT[m[KH",

1214+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.win.x64/Crypto/SelfTest/Signature/test_vectors/wycheproof/ecdsa_test.json[m[K[36m[K:[m[K[32m[K12177[m[K[36m[K:[m[K "keyPem" : "-----BEGIN PUBLIC KEY-----\nMGowFAYHKoZIzj0CAQYJKyQDAwIIAQEJA1IABHJlM+Jnc6xyChF[1;33m[KbAt[m[K6JrBWWZnfi\nObfFd6HBW4ECex/rc+ZzYB4hGqkqzLWFvAbMJ0thyeYUdG7dJI0czPjYsatLwVzF\njN8RYGXOl2fyoyI9\n-----END PUBLIC KEY-----",

1215+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.win.x64/Crypto/SelfTest/Signature/test_vectors/wycheproof/ecdsa_test.json[m[K[36m[K:[m[K[32m[K13141[m[K[36m[K:[m[K "keyPem" : "-----BEGIN PUBLIC KEY-----\nMHowFAYHKoZIzj0CAQYJKyQDAwIIAQELA2IA[1;33m[KBAT[m[KZ1KYtbrAgc+c4seQ5zs1UQAMZ\nEfRRkOtgYqM1NfxSabz8JdSvwdrg662UjXcy2AKa836Jo86n3ziwIPYkkG/KbZRO\nFIaFP+jlupz7otdKhS7Fh9Rv5JkXw2RBjvfspQ==\n-----END PUBLIC KEY-----",

1216+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.win.x64/Crypto/SelfTest/Signature/test_vectors/wycheproof/ecdsa_secp256r1_sha256_test.json[m[K[36m[K:[m[K[32m[K2410[m[K[36m[K:[m[K "keyPem" : "-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3q0Rx6WzloYvIZdNxHUvre/5lO/p\nu9[1;33m[KBat[m[KBN2XqgLbh8d4/BkDorG7c+Jz/U8QOJlu5QHijQ3Nt8HqgMY/H/h/w==\n-----END PUBLIC KEY-----",

1217+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.win.x64/Crypto/SelfTest/PublicKey/test_import_RSA.py[m[K[36m[K:[m[K[32m[K444[m[K[36m[K:[m[KMIIEcjCCAlqgAwIBAgI[1;33m[KBAT[m[KANBgkqhkiG9w0BAQsFADBhMQswCQYDVQQGEwJVUzEL

1218+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.osx.x64/Crypto/Util/RFC1751.py[m[K[36m[K:[m[K[32m[K125[m[K[36m[K:[m[K "BAN", "BAR", "[1;33m[KBAT[m[K", "BAY", "BE", "BED", "BEE", "BEG", "BEN", "BET",

1219+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.osx.x64/Crypto/Util/RFC1751.py[m[K[36m[K:[m[K[32m[K189[m[K[36m[K:[m[K "BARN", "BARR", "BASE", "BASH", "BASK", "BASS", "[1;33m[KBAT[m[KE", "[1;33m[KBAT[m[KH",

1220+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.osx.x64/Crypto/SelfTest/Signature/test_vectors/wycheproof/ecdsa_test.json[m[K[36m[K:[m[K[32m[K12177[m[K[36m[K:[m[K "keyPem" : "-----BEGIN PUBLIC KEY-----\nMGowFAYHKoZIzj0CAQYJKyQDAwIIAQEJA1IABHJlM+Jnc6xyChF[1;33m[KbAt[m[K6JrBWWZnfi\nObfFd6HBW4ECex/rc+ZzYB4hGqkqzLWFvAbMJ0thyeYUdG7dJI0czPjYsatLwVzF\njN8RYGXOl2fyoyI9\n-----END PUBLIC KEY-----",

1221+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.osx.x64/Crypto/SelfTest/Signature/test_vectors/wycheproof/ecdsa_test.json[m[K[36m[K:[m[K[32m[K13141[m[K[36m[K:[m[K "keyPem" : "-----BEGIN PUBLIC KEY-----\nMHowFAYHKoZIzj0CAQYJKyQDAwIIAQELA2IA[1;33m[KBAT[m[KZ1KYtbrAgc+c4seQ5zs1UQAMZ\nEfRRkOtgYqM1NfxSabz8JdSvwdrg662UjXcy2AKa836Jo86n3ziwIPYkkG/KbZRO\nFIaFP+jlupz7otdKhS7Fh9Rv5JkXw2RBjvfspQ==\n-----END PUBLIC KEY-----",

1222+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.osx.x64/Crypto/SelfTest/Signature/test_vectors/wycheproof/ecdsa_secp256r1_sha256_test.json[m[K[36m[K:[m[K[32m[K2410[m[K[36m[K:[m[K "keyPem" : "-----BEGIN PUBLIC KEY-----\nMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE3q0Rx6WzloYvIZdNxHUvre/5lO/p\nu9[1;33m[KBat[m[KBN2XqgLbh8d4/BkDorG7c+Jz/U8QOJlu5QHijQ3Nt8HqgMY/H/h/w==\n-----END PUBLIC KEY-----",

1223+[35m[Kassets/syntaxes/02_Extra/MediaWiki/lib/Crypto.osx.x64/Crypto/SelfTest/PublicKey/test_import_RSA.py[m[K[36m[K:[m[K[32m[K444[m[K[36m[K:[m[KMIIEcjCCAlqgAwIBAgI[1;33m[KBAT[m[KANBgkqhkiG9w0BAQsFADBhMQswCQYDVQQGEwJVUzEL

1224+[35m[Kassets/syntaxes/02_Extra/Julia/julia_unicode/emoji_symbols.py[m[K[36m[K:[m[K[32m[K69[m[K[36m[K:[m[K ("\\:[1;33m[Kbat[m[Ktery:", u"🔋"),

1225+[35m[Kassets/syntaxes/02_Extra/Julia/julia_unicode/emoji_symbols.py[m[K[36m[K:[m[K[32m[K576[m[K[36m[K:[m[K ("\\:tana[1;33m[Kbat[m[Ka_tree:", u"🎋"),

1226+[35m[Kassets/syntaxes/02_Extra/Julia/julia_unicode/emoji_symbols.py[m[K[36m[K:[m[K[32m[K729[m[K[36m[K:[m[K ("\\:[1;33m[Kbat[m[Kh:", u"🛀"),

1227+[35m[Kassets/syntaxes/02_Extra/Julia/julia_unicode/emoji_symbols.py[m[K[36m[K:[m[K[32m[K804[m[K[36m[K:[m[K ("\\:[1;33m[Kbat[m[Khtub:", u"🛁"),

1229+[35m[Kassets/syntaxes/02_Extra/Dart/docgen.py[m[K[36m[K:[m[K[32m[K30[m[K[36m[K:[m[K cmd = ["docgen.[1;33m[Kbat[m[K", "--no-include-sdk", path]

1230+[35m[Kassets/syntaxes/02_Extra/Dart/docgen.py[m[K[36m[K:[m[K[32m[K58[m[K[36m[K:[m[K cmd = ["docgen.[1;33m[Kbat[m[K", "--no-include-sdk", "--serve", path]

1231+[35m[Kassets/syntaxes/02_Extra/Dart/lib/sdk.py[m[K[36m[K:[m[K[32m[K177[m[K[36m[K:[m[K return self.get_bin_tool('pub', '.[1;33m[Kbat[m[K')

1232+[35m[Kassets/syntaxes/02_Extra/Dart/lib/sdk.py[m[K[36m[K:[m[K[32m[K183[m[K[36m[K:[m[K return self.get_bin_tool('dart2js', '.[1;33m[Kbat[m[K')

1233+[35m[Kassets/syntaxes/02_Extra/Dart/lib/sdk.py[m[K[36m[K:[m[K[32m[K189[m[K[36m[K:[m[K return self.get_bin_tool('dartanalyzer', '.[1;33m[Kbat[m[K')

1234+[35m[Kassets/syntaxes/02_Extra/Dart/lib/sdk.py[m[K[36m[K:[m[K[32m[K195[m[K[36m[K:[m[K return self.get_bin_tool('docgen', '.[1;33m[Kbat[m[K')

1235+[35m[Kassets/syntaxes/02_Extra/Dart/lib/sdk.py[m[K[36m[K:[m[K[32m[K247[m[K[36m[K:[m[K self.path = SDK().get_bin_tool('dartfmt', '.[1;33m[Kbat[m[K')

1236+[35m[Kassets/syntaxes/02_Extra/Dart/sublime_plugin_lib/path.py[m[K[36m[K:[m[K[32m[K142[m[K[36m[K:[m[K Useful to add .exe to @original, .[1;33m[Kbat[m[K, etc if ST is running on Windows.

1237+[35m[Kassets/syntaxes/02_Extra/Dart/sublime_plugin_lib/path.py[m[K[36m[K:[m[K[32m[K186[m[K[36m[K:[m[K """ Useful to add .exe, .[1;33m[Kbat[m[K, etc. to @original if ST is running on

1238+[35m[Kassets/syntaxes/02_Extra/Dart/Support/Dart.sublime-build[m[K[36m[K:[m[K[32m[K19[m[K[36m[K:[m[K "cmd": ["dart2js.[1;33m[Kbat[m[K", "--minify", "-o$file.js", "$file"]

1239+[35m[Kassets/syntaxes/02_Extra/Dart/Support/Dart - Pubspec.sublime-build[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[K "cmd": ["pub.[1;33m[Kbat[m[K", "upgrade"]

1240+[35m[Kassets/syntaxes/02_Extra/Dart/Support/Dart - Pubspec.sublime-build[m[K[36m[K:[m[K[32m[K36[m[K[36m[K:[m[K "cmd": ["pub.[1;33m[Kbat[m[K", "version"]

1241+[35m[Kassets/syntaxes/02_Extra/LESS/Syntaxes/LESS.sublime-syntax[m[K[36m[K:[m[K[32m[K1709[m[K[36m[K:[m[K - match: '\[1;33m[Kbat[m[K\b'

1242+[35m[Kassets/syntaxes/02_Extra/Email/README.md[m[K[36m[K:[m[K[32m[K15[m[K[36m[K:[m[K:mouse: Using [[1;33m[Kbat[m[K](https://github.com/sharkdp/[1;33m[Kbat[m[K) *([1;33m[Kbat[m[K is a cat clone with syntax highlighting and Git integration)*

1243+[35m[Kassets/syntaxes/02_Extra/Email/README.md[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[K![[1;33m[Kbat[m[K](https://raw.githubusercontent.com/mariozaizar/email.sublime-syntax/master/demo/[1;33m[Kbat[m[K.png)

1244+[35m[Kassets/syntaxes/02_Extra/Email/link_bat.sh[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K# We use [1;33m[Kbat[m[K to verify the sintax. [1;33m[Kbat[m[K is a cat clone with syntax highlighting

1245+[35m[Kassets/syntaxes/02_Extra/Email/link_bat.sh[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K# and Git integration. [1;33m[Kbat[m[K uses syntect library for syntax highlighting which

1246+[35m[Kassets/syntaxes/02_Extra/Email/link_bat.sh[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K# https://github.com/sharkdp/[1;33m[Kbat[m[K

1247+[35m[Kassets/syntaxes/02_Extra/Email/link_bat.sh[m[K[36m[K:[m[K[32m[K9[m[K[36m[K:[m[K[1;33m[Kbat[m[K --version || brew install [1;33m[Kbat[m[K # Mac OS only

1248+[35m[Kassets/syntaxes/02_Extra/Email/link_bat.sh[m[K[36m[K:[m[K[32m[K11[m[K[36m[K:[m[K[1;33m[KBAT[m[K_PATH=$([1;33m[Kbat[m[K --config-dir)

1249+[35m[Kassets/syntaxes/02_Extra/Email/link_bat.sh[m[K[36m[K:[m[K[32m[K13[m[K[36m[K:[m[Kmkdir -p "$[1;33m[KBAT[m[K_PATH/syntaxes"

1250+[35m[Kassets/syntaxes/02_Extra/Email/link_bat.sh[m[K[36m[K:[m[K[32m[K14[m[K[36m[K:[m[Kmkdir -p "$[1;33m[KBAT[m[K_PATH/themes"

1251+[35m[Kassets/syntaxes/02_Extra/Email/link_bat.sh[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[KINSTALL_PATH=${[1;33m[KBAT[m[K_PATH}/syntaxes

1252+[35m[Kassets/syntaxes/02_Extra/Email/link_bat.sh[m[K[36m[K:[m[K[32m[K19[m[K[36m[K:[m[K[1;33m[Kbat[m[K cache --build

1253+[35m[Kassets/syntaxes/02_Extra/Email/link_bat.sh[m[K[36m[K:[m[K[32m[K20[m[K[36m[K:[m[K[1;33m[Kbat[m[K --list-languages | grep "Email"

1254+[35m[Kassets/syntaxes/02_Extra/Email/link_bat.sh[m[K[36m[K:[m[K[32m[K22[m[K[36m[K:[m[K[1;33m[Kbat[m[K demo/email.eml

1256+[35m[Kassets/syntaxes/02_Extra/HTML (Twig)/Preferences/Indentation.tmPreferences[m[K[36m[K:[m[K[32m[K22[m[K[36m[K:[m[K ^\s*\{%-?\s(end(?:autoescape|block|embed|filter|for|if|macro|raw|sandbox|set|spaceless|trans|ver[1;33m[Kbat[m[Kim)|(else))(?:(?!%\}).)*\s-?%\}

1257+[35m[Kassets/syntaxes/02_Extra/HTML (Twig)/Preferences/Indentation.tmPreferences[m[K[36m[K:[m[K[32m[K36[m[K[36m[K:[m[K ^\s*\{%-?\s(autoescape|block|embed|filter|for|if|else|macro|raw|sandbox|set|spaceless|trans|ver[1;33m[Kbat[m[Kim)(?:(?!%\}).)*\s-?%\}(?!.*\{%-?\send\1)

1258+[35m[Kassets/syntaxes/02_Extra/HTML (Twig)/Preferences/Folding.tmPreferences[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[K |\{%\s+(autoescape|block|embed|filter|for|if|macro|raw|sandbox|set|spaceless|trans|ver[1;33m[Kbat[m[Kim)

1259+[35m[Kassets/syntaxes/02_Extra/HTML (Twig)/Preferences/Folding.tmPreferences[m[K[36m[K:[m[K[32m[K23[m[K[36m[K:[m[K |\{%\s+end(autoescape|block|embed|filter|for|if|macro|raw|sandbox|set|spaceless|trans|ver[1;33m[Kbat[m[Kim)

1260+[35m[Kassets/syntaxes/02_Extra/HTML (Twig)/Snippets/verbatim.tmSnippet[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K <string>{% ver[1;33m[Kbat[m[Kim %}

1261+[35m[Kassets/syntaxes/02_Extra/HTML (Twig)/Snippets/verbatim.tmSnippet[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[K{% endver[1;33m[Kbat[m[Kim %}</string>

1262+[35m[Kassets/syntaxes/02_Extra/HTML (Twig)/Snippets/verbatim.tmSnippet[m[K[36m[K:[m[K[32m[K10[m[K[36m[K:[m[K <string>ver[1;33m[Kbat[m[Kim</string>

1263+[35m[Kassets/syntaxes/02_Extra/HTML (Twig)/Snippets/verbatim.tmSnippet[m[K[36m[K:[m[K[32m[K14[m[K[36m[K:[m[K <string>ver[1;33m[Kbat[m[Kim</string>

1265+[35m[Kassets/syntaxes/02_Extra/HTML (Twig)/Syntaxes/HTML (Twig).tmLanguage[m[K[36m[K:[m[K[32m[K1590[m[K[36m[K:[m[K <string>(?<=(?:[a-zA-Z0-9_\x{7f}-\x{ff}\]\)\'\"]\|)|\{%\sfilter\s)([1;33m[Kbat[m[Kch|convert_encoding|date|date_modify|default|e(?:scape)?|format|join|merge|number_format|replace|round|slice|split|trim)(\()</string>

1266+[35m[Kassets/syntaxes/02_Extra/requirementstxt/LICENSE[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K Everyone is permitted to copy and distribute ver[1;33m[Kbat[m[Kim copies

1267+[35m[Kassets/syntaxes/02_Extra/requirementstxt/LICENSE[m[K[36m[K:[m[K[32m[K195[m[K[36m[K:[m[K 4. Conveying Ver[1;33m[Kbat[m[Kim Copies.

1268+[35m[Kassets/syntaxes/02_Extra/requirementstxt/LICENSE[m[K[36m[K:[m[K[32m[K197[m[K[36m[K:[m[K You may convey ver[1;33m[Kbat[m[Kim copies of the Program's source code as you

1269+[35m[Kassets/syntaxes/01_Packages/Batch File/Symbol List.tmPreferences[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K <string>source.dos[1;33m[Kbat[m[Kch entity.name.label - meta.function-call</string>

1270+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[Kname: [1;33m[KBat[m[Kch File

1271+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K - [1;33m[Kbat[m[K

1272+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[Kscope: source.dos[1;33m[Kbat[m[Kch

1273+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K31[m[K[36m[K:[m[K scope: keyword.control.statement.dos[1;33m[Kbat[m[Kch

1274+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K34[m[K[36m[K:[m[K 1: keyword.control.statement.dos[1;33m[Kbat[m[Kch

1275+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K35[m[K[36m[K:[m[K 2: punctuation.separator.dos[1;33m[Kbat[m[Kch

1276+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K36[m[K[36m[K:[m[K 3: keyword.control.flow.return.dos[1;33m[Kbat[m[Kch

1277+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K37[m[K[36m[K:[m[K 4: meta.function-call.dos[1;33m[Kbat[m[Kch variable.function.dos[1;33m[Kbat[m[Kch

1278+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K40[m[K[36m[K:[m[K 1: keyword.control.conditional.dos[1;33m[Kbat[m[Kch

1279+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K41[m[K[36m[K:[m[K 2: keyword.operator.logical.dos[1;33m[Kbat[m[Kch

1280+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K42[m[K[36m[K:[m[K 3: keyword.other.dos[1;33m[Kbat[m[Kch

1281+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K44[m[K[36m[K:[m[K scope: keyword.control.conditional.dos[1;33m[Kbat[m[Kch

1282+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K46[m[K[36m[K:[m[K scope: keyword.control.repeat.dos[1;33m[Kbat[m[Kch

1283+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K50[m[K[36m[K:[m[K scope: keyword.command.dos[1;33m[Kbat[m[Kch

1284+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K60[m[K[36m[K:[m[K scope: keyword.command.dos[1;33m[Kbat[m[Kch

1285+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K64[m[K[36m[K:[m[K scope: keyword.command.dos[1;33m[Kbat[m[Kch

1286+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K74[m[K[36m[K:[m[K 1: punctuation.definition.string.begin.dos[1;33m[Kbat[m[Kch

1287+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K75[m[K[36m[K:[m[K 2: variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1288+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K76[m[K[36m[K:[m[K 3: keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1289+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K78[m[K[36m[K:[m[K - meta_scope: string.quoted.double.dos[1;33m[Kbat[m[Kch

1290+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K80[m[K[36m[K:[m[K scope: punctuation.definition.string.end.dos[1;33m[Kbat[m[Kch

1291+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K88[m[K[36m[K:[m[K 1: variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1292+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K89[m[K[36m[K:[m[K 2: keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1293+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K91[m[K[36m[K:[m[K - meta_content_scope: string.unquoted.dos[1;33m[Kbat[m[Kch

1294+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K96[m[K[36m[K:[m[K scope: punctuation.definition.string.begin.dos[1;33m[Kbat[m[Kch

1295+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K98[m[K[36m[K:[m[K - meta_scope: string.quoted.double.dos[1;33m[Kbat[m[Kch

1296+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K101[m[K[36m[K:[m[K scope: punctuation.definition.string.end.dos[1;33m[Kbat[m[Kch

1297+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K108[m[K[36m[K:[m[K scope: variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1298+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K112[m[K[36m[K:[m[K - meta_content_scope: meta.expression.set.dos[1;33m[Kbat[m[Kch

1299+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K120[m[K[36m[K:[m[K 1: variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1300+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K121[m[K[36m[K:[m[K 2: keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1301+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K123[m[K[36m[K:[m[K - meta_scope: meta.prompt.set.dos[1;33m[Kbat[m[Kch

1302+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K132[m[K[36m[K:[m[K scope: comment.line.ignored.dos[1;33m[Kbat[m[Kch

1303+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K135[m[K[36m[K:[m[K - meta_content_scope: string.unquoted.dos[1;33m[Kbat[m[Kch

1304+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K145[m[K[36m[K:[m[K scope: punctuation.section.group.begin.dos[1;33m[Kbat[m[Kch

1305+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K148[m[K[36m[K:[m[K scope: punctuation.definition.string.begin.dos[1;33m[Kbat[m[Kch

1306+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K153[m[K[36m[K:[m[K - meta_scope: meta.group.dos[1;33m[Kbat[m[Kch

1307+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K155[m[K[36m[K:[m[K scope: punctuation.section.group.end.dos[1;33m[Kbat[m[Kch

1308+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K158[m[K[36m[K:[m[K scope: punctuation.definition.string.begin.dos[1;33m[Kbat[m[Kch

1309+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K164[m[K[36m[K:[m[K scope: keyword.operator.assignment.augmented.dos[1;33m[Kbat[m[Kch

1310+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K167[m[K[36m[K:[m[K 1: constant.character.escape.dos[1;33m[Kbat[m[Kch

1311+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K168[m[K[36m[K:[m[K 2: keyword.operator.assignment.augmented.dos[1;33m[Kbat[m[Kch

1312+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K170[m[K[36m[K:[m[K scope: keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1313+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K173[m[K[36m[K:[m[K 1: constant.character.escape.dos[1;33m[Kbat[m[Kch

1314+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K174[m[K[36m[K:[m[K 2: keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1315+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K176[m[K[36m[K:[m[K scope: keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1316+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K180[m[K[36m[K:[m[K scope: keyword.operator.assignment.augmented.dos[1;33m[Kbat[m[Kch

1317+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K182[m[K[36m[K:[m[K scope: keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1318+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K186[m[K[36m[K:[m[K - meta_scope: string.quoted.double.dos[1;33m[Kbat[m[Kch

1319+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K190[m[K[36m[K:[m[K scope: punctuation.definition.string.end.dos[1;33m[Kbat[m[Kch

1320+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K193[m[K[36m[K:[m[K scope: punctuation.section.group.begin.dos[1;33m[Kbat[m[Kch

1321+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K195[m[K[36m[K:[m[K - meta_scope: meta.group.dos[1;33m[Kbat[m[Kch

1322+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K202[m[K[36m[K:[m[K - meta_scope: meta.group.dos[1;33m[Kbat[m[Kch

1323+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K204[m[K[36m[K:[m[K scope: punctuation.section.group.end.dos[1;33m[Kbat[m[Kch

1324+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K207[m[K[36m[K:[m[K scope: punctuation.definition.string.end.dos[1;33m[Kbat[m[Kch

1325+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K214[m[K[36m[K:[m[K - meta_scope: string.quoted.double.dos[1;33m[Kbat[m[Kch meta.group.dos[1;33m[Kbat[m[Kch

1326+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K216[m[K[36m[K:[m[K scope: punctuation.section.group.begin.dos[1;33m[Kbat[m[Kch

1327+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K219[m[K[36m[K:[m[K scope: punctuation.section.group.end.dos[1;33m[Kbat[m[Kch

1328+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K227[m[K[36m[K:[m[K scope: keyword.operator.logical.dos[1;33m[Kbat[m[Kch

1329+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K233[m[K[36m[K:[m[K scope: variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1330+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K238[m[K[36m[K:[m[K scope: variable.parameter.dos[1;33m[Kbat[m[Kch

1331+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K240[m[K[36m[K:[m[K 1: punctuation.definition.variable.dos[1;33m[Kbat[m[Kch

1332+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K242[m[K[36m[K:[m[K scope: variable.language.dos[1;33m[Kbat[m[Kch

1333+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K244[m[K[36m[K:[m[K 1: punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1334+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K245[m[K[36m[K:[m[K 2: punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1335+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K252[m[K[36m[K:[m[K scope: punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1336+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K254[m[K[36m[K:[m[K - meta_scope: variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1337+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K257[m[K[36m[K:[m[K 1: punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1338+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K261[m[K[36m[K:[m[K scope: punctuation.separator.dos[1;33m[Kbat[m[Kch

1339+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K263[m[K[36m[K:[m[K - meta_content_scope: meta.variable.substring.dos[1;33m[Kbat[m[Kch

1340+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K269[m[K[36m[K:[m[K scope: punctuation.separator.dos[1;33m[Kbat[m[Kch

1341+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K271[m[K[36m[K:[m[K - meta_content_scope: meta.variable.substitution.dos[1;33m[Kbat[m[Kch

1342+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K276[m[K[36m[K:[m[K scope: punctuation.separator.dos[1;33m[Kbat[m[Kch

1343+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K282[m[K[36m[K:[m[K scope: string.unquoted.dos[1;33m[Kbat[m[Kch

1344+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K287[m[K[36m[K:[m[K scope: punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1345+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K289[m[K[36m[K:[m[K - meta_scope: variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1346+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K292[m[K[36m[K:[m[K 1: punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1347+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K296[m[K[36m[K:[m[K scope: punctuation.separator.dos[1;33m[Kbat[m[Kch

1348+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K298[m[K[36m[K:[m[K - meta_content_scope: meta.variable.substring.dos[1;33m[Kbat[m[Kch

1349+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K304[m[K[36m[K:[m[K scope: punctuation.separator.dos[1;33m[Kbat[m[Kch

1350+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K306[m[K[36m[K:[m[K - meta_content_scope: meta.variable.substitution.dos[1;33m[Kbat[m[Kch

1351+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K312[m[K[36m[K:[m[K scope: punctuation.separator.dos[1;33m[Kbat[m[Kch

1352+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K318[m[K[36m[K:[m[K scope: string.unquoted.dos[1;33m[Kbat[m[Kch

1353+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K322[m[K[36m[K:[m[K scope: string.unquoted.dos[1;33m[Kbat[m[Kch

1354+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K326[m[K[36m[K:[m[K scope: constant.numeric.dos[1;33m[Kbat[m[Kch

1355+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K331[m[K[36m[K:[m[K scope: punctuation.separator.dos[1;33m[Kbat[m[Kch

1356+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K335[m[K[36m[K:[m[K scope: constant.numeric.integer.hexadecimal.dos[1;33m[Kbat[m[Kch

1357+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K337[m[K[36m[K:[m[K 1: punctuation.definition.numeric.hexadecimal.dos[1;33m[Kbat[m[Kch

1358+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K339[m[K[36m[K:[m[K scope: constant.numeric.integer.octal.dos[1;33m[Kbat[m[Kch

1359+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K341[m[K[36m[K:[m[K 1: punctuation.definition.numeric.octal.dos[1;33m[Kbat[m[Kch

1360+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K343[m[K[36m[K:[m[K scope: constant.numeric.integer.decimal.dos[1;33m[Kbat[m[Kch

1361+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K347[m[K[36m[K:[m[K scope: constant.language.dos[1;33m[Kbat[m[Kch

1362+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K351[m[K[36m[K:[m[K scope: keyword.operator.at.dos[1;33m[Kbat[m[Kch

1363+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K353[m[K[36m[K:[m[K scope: keyword.operator.comparison.dos[1;33m[Kbat[m[Kch

1364+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K355[m[K[36m[K:[m[K scope: keyword.operator.logical.dos[1;33m[Kbat[m[Kch

1365+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K357[m[K[36m[K:[m[K scope: keyword.operator.conditional.dos[1;33m[Kbat[m[Kch

1366+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K359[m[K[36m[K:[m[K scope: keyword.operator.pipe.dos[1;33m[Kbat[m[Kch

1367+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K361[m[K[36m[K:[m[K scope: keyword.operator.redirection.dos[1;33m[Kbat[m[Kch

1368+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K366[m[K[36m[K:[m[K 1: punctuation.separator.dos[1;33m[Kbat[m[Kch

1369+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K367[m[K[36m[K:[m[K 2: entity.name.label.dos[1;33m[Kbat[m[Kch

1370+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K372[m[K[36m[K:[m[K 1: keyword.operator.conditional.dos[1;33m[Kbat[m[Kch

1371+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K375[m[K[36m[K:[m[K scope: comment.line.rem.dos[1;33m[Kbat[m[Kch

1372+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K378[m[K[36m[K:[m[K scope: punctuation.definition.comment.dos[1;33m[Kbat[m[Kch

1373+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K380[m[K[36m[K:[m[K - meta_scope: comment.line.colon.dos[1;33m[Kbat[m[Kch

1374+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K386[m[K[36m[K:[m[K scope: keyword.command.rem.dos[1;33m[Kbat[m[Kch

1375+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K390[m[K[36m[K:[m[K - meta_content_scope: comment.line.rem.dos[1;33m[Kbat[m[Kch

1376+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K392[m[K[36m[K:[m[K scope: comment.line.rem.dos[1;33m[Kbat[m[Kch

1377+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K395[m[K[36m[K:[m[K scope: invalid.illegal.unexpected-character.dos[1;33m[Kbat[m[Kch

1378+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K399[m[K[36m[K:[m[K scope: punctuation.definition.string.begin.dos[1;33m[Kbat[m[Kch

1379+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K401[m[K[36m[K:[m[K - meta_scope: string.quoted.double.dos[1;33m[Kbat[m[Kch

1380+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K404[m[K[36m[K:[m[K 1: punctuation.definition.string.end.dos[1;33m[Kbat[m[Kch

1381+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K405[m[K[36m[K:[m[K 2: invalid.illegal.newline.dos[1;33m[Kbat[m[Kch

1382+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K412[m[K[36m[K:[m[K scope: punctuation.section.group.begin.dos[1;33m[Kbat[m[Kch

1383+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K414[m[K[36m[K:[m[K - meta_scope: meta.group.dos[1;33m[Kbat[m[Kch

1384+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K416[m[K[36m[K:[m[K scope: punctuation.section.group.end.dos[1;33m[Kbat[m[Kch

1385+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K419[m[K[36m[K:[m[K scope: punctuation.separator.dos[1;33m[Kbat[m[Kch

1386+[35m[Kassets/syntaxes/01_Packages/Batch File/Batch File.sublime-syntax[m[K[36m[K:[m[K[32m[K424[m[K[36m[K:[m[K scope: constant.character.escape.dos[1;33m[Kbat[m[Kch

1387+[35m[Kassets/syntaxes/01_Packages/Batch File/Comments.tmPreferences[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K <string>source.dos[1;33m[Kbat[m[Kch</string>

1388+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K:: SYNTAX TEST "Packages/[1;33m[KBat[m[Kch File/[1;33m[KBat[m[Kch File.sublime-syntax"

1389+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K:: ^^^ keyword.command.rem.dos[1;33m[Kbat[m[Kch

1390+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^^^^ comment.line.rem.dos[1;33m[Kbat[m[Kch

1391+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K:: ^ invalid.illegal.unexpected-character.dos[1;33m[Kbat[m[Kch

1392+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K:: ^ invalid.illegal.unexpected-character.dos[1;33m[Kbat[m[Kch

1393+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[K:: ^ invalid.illegal.unexpected-character.dos[1;33m[Kbat[m[Kch

1394+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K12[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^ - comment.line.rem.dos[1;33m[Kbat[m[Kch

1395+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K19[m[K[36m[K:[m[K:: ^^ punctuation.definition.comment.dos[1;33m[Kbat[m[Kch

1396+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K20[m[K[36m[K:[m[K:: ^^^^^^^^^^ comment.line.colon.dos[1;33m[Kbat[m[Kch

1397+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K23[m[K[36m[K:[m[K:: ^^ punctuation.definition.comment.dos[1;33m[Kbat[m[Kch

1398+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K26[m[K[36m[K:[m[K:: ^^ punctuation.definition.comment.dos[1;33m[Kbat[m[Kch

1399+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K29[m[K[36m[K:[m[K:: ^^ punctuation.definition.comment.dos[1;33m[Kbat[m[Kch

1400+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K32[m[K[36m[K:[m[K:: ^^ punctuation.definition.comment.dos[1;33m[Kbat[m[Kch

1401+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K35[m[K[36m[K:[m[K:: ^^ punctuation.definition.comment.dos[1;33m[Kbat[m[Kch

1402+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K46[m[K[36m[K:[m[K:: ^ keyword.operator.conditional.dos[1;33m[Kbat[m[Kch

1403+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K47[m[K[36m[K:[m[K:: ^^ punctuation.definition.comment.dos[1;33m[Kbat[m[Kch

1404+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K48[m[K[36m[K:[m[K:: ^^^^^^^^^^^^ comment.line.colon.dos[1;33m[Kbat[m[Kch

1405+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K51[m[K[36m[K:[m[K::^^ punctuation.definition.comment.dos[1;33m[Kbat[m[Kch

1406+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K52[m[K[36m[K:[m[K::^^^^^^^^^^^^^^^^^^^^^^ comment.line.colon.dos[1;33m[Kbat[m[Kch

1407+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K55[m[K[36m[K:[m[K:: ^ punctuation.definition.string.begin.dos[1;33m[Kbat[m[Kch

1408+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K56[m[K[36m[K:[m[K:: ^^^^^ string.quoted.double.dos[1;33m[Kbat[m[Kch

1409+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K57[m[K[36m[K:[m[K:: ^ punctuation.definition.string.end.dos[1;33m[Kbat[m[Kch

1410+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K60[m[K[36m[K:[m[K:: ^ invalid.illegal.newline.dos[1;33m[Kbat[m[Kch

1411+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K63[m[K[36m[K:[m[K:: ^ keyword.operator.at.dos[1;33m[Kbat[m[Kch

1412+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K66[m[K[36m[K:[m[K:: ^ - keyword.operator.at.dos[1;33m[Kbat[m[Kch

1413+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K69[m[K[36m[K:[m[K:: ^^^^ keyword.control.statement.dos[1;33m[Kbat[m[Kch

1414+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K70[m[K[36m[K:[m[K:: ^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1415+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K71[m[K[36m[K:[m[K:: ^^^ keyword.control.flow.return.dos[1;33m[Kbat[m[Kch

1416+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K74[m[K[36m[K:[m[K:: ^^^^ keyword.control.statement.dos[1;33m[Kbat[m[Kch

1417+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K75[m[K[36m[K:[m[K:: ^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1418+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K76[m[K[36m[K:[m[K:: ^^^ meta.function-call.dos[1;33m[Kbat[m[Kch variable.function.dos[1;33m[Kbat[m[Kch

1419+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K79[m[K[36m[K:[m[K:: ^^^^ keyword.control.statement.dos[1;33m[Kbat[m[Kch

1420+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K80[m[K[36m[K:[m[K:: ^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1421+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K81[m[K[36m[K:[m[K:: ^^^ meta.function-call.dos[1;33m[Kbat[m[Kch variable.function.dos[1;33m[Kbat[m[Kch

1422+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K85[m[K[36m[K:[m[K:: ^^^^ keyword.command.dos[1;33m[Kbat[m[Kch

1423+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K86[m[K[36m[K:[m[K:: ^ keyword.operator.redirection.dos[1;33m[Kbat[m[Kch

1424+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K89[m[K[36m[K:[m[K:: ^^ keyword.operator.redirection.dos[1;33m[Kbat[m[Kch

1425+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K93[m[K[36m[K:[m[K:: ^ keyword.operator.redirection.dos[1;33m[Kbat[m[Kch

1426+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K94[m[K[36m[K:[m[K:: ^^ keyword.operator.redirection.dos[1;33m[Kbat[m[Kch

1427+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K97[m[K[36m[K:[m[K:: ^^ keyword.operator.conditional.dos[1;33m[Kbat[m[Kch

1428+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K98[m[K[36m[K:[m[K:: ^^ keyword.operator.conditional.dos[1;33m[Kbat[m[Kch

1429+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K99[m[K[36m[K:[m[K:: ^ keyword.operator.conditional.dos[1;33m[Kbat[m[Kch

1430+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K103[m[K[36m[K:[m[K:: ^^ keyword.control.conditional.dos[1;33m[Kbat[m[Kch

1431+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K104[m[K[36m[K:[m[K:: ^^^ keyword.operator.comparison.dos[1;33m[Kbat[m[Kch

1432+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K107[m[K[36m[K:[m[K:: ^^ keyword.control.conditional.dos[1;33m[Kbat[m[Kch

1433+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K108[m[K[36m[K:[m[K:: ^^^ keyword.operator.logical.dos[1;33m[Kbat[m[Kch

1434+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K109[m[K[36m[K:[m[K:: ^^^ keyword.operator.comparison.dos[1;33m[Kbat[m[Kch

1435+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K113[m[K[36m[K:[m[K:: ^^ keyword.control.conditional.dos[1;33m[Kbat[m[Kch

1436+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K114[m[K[36m[K:[m[K:: ^^^^^^^^^^^^ variable.language.dos[1;33m[Kbat[m[Kch

1437+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K115[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1438+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K116[m[K[36m[K:[m[K:: ^ variable.language.dos[1;33m[Kbat[m[Kch punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1439+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K119[m[K[36m[K:[m[K:: ^^ keyword.control.conditional.dos[1;33m[Kbat[m[Kch

1440+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K120[m[K[36m[K:[m[K:: ^^ keyword.operator.comparison.dos[1;33m[Kbat[m[Kch

1441+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K123[m[K[36m[K:[m[K:: ^^^ keyword.control.repeat.dos[1;33m[Kbat[m[Kch

1442+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K124[m[K[36m[K:[m[K:: ^ constant.numeric.integer.decimal.dos[1;33m[Kbat[m[Kch

1443+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K127[m[K[36m[K:[m[K:: ^ keyword.operator.pipe.dos[1;33m[Kbat[m[Kch

1444+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K130[m[K[36m[K:[m[K::^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1445+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K131[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ entity.name.label.dos[1;33m[Kbat[m[Kch

1446+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K134[m[K[36m[K:[m[K::^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1447+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K135[m[K[36m[K:[m[K:: ^^^ entity.name.label.dos[1;33m[Kbat[m[Kch

1448+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K138[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.dos[1;33m[Kbat[m[Kch

1449+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K139[m[K[36m[K:[m[K:: ^^ variable.parameter.dos[1;33m[Kbat[m[Kch

1450+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K140[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.dos[1;33m[Kbat[m[Kch

1451+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K141[m[K[36m[K:[m[K:: ^^ variable.parameter.dos[1;33m[Kbat[m[Kch

1452+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K142[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.dos[1;33m[Kbat[m[Kch

1453+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K143[m[K[36m[K:[m[K:: ^^^^^^^^^^^ variable.parameter.dos[1;33m[Kbat[m[Kch

1454+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K144[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.dos[1;33m[Kbat[m[Kch

1455+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K145[m[K[36m[K:[m[K:: ^^^ variable.parameter.dos[1;33m[Kbat[m[Kch

1456+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K148[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1457+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K149[m[K[36m[K:[m[K:: ^^^^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1458+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K150[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1459+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K151[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1460+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K152[m[K[36m[K:[m[K:: ^^^^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1461+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K153[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1462+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K156[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1463+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K157[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1464+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K158[m[K[36m[K:[m[K:: ^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1465+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K159[m[K[36m[K:[m[K:: ^^^^^^^^^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch

1466+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K160[m[K[36m[K:[m[K:: ^^^^ string.unquoted.dos[1;33m[Kbat[m[Kch

1467+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K161[m[K[36m[K:[m[K:: ^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1468+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K162[m[K[36m[K:[m[K:: ^^^^ string.unquoted.dos[1;33m[Kbat[m[Kch

1469+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K163[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1470+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K164[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1471+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K165[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1472+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K166[m[K[36m[K:[m[K:: ^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1473+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K167[m[K[36m[K:[m[K:: ^^^^^^^^^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch

1474+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K168[m[K[36m[K:[m[K:: ^^^^ string.unquoted.dos[1;33m[Kbat[m[Kch

1475+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K169[m[K[36m[K:[m[K:: ^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1476+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K170[m[K[36m[K:[m[K:: ^^^^ string.unquoted.dos[1;33m[Kbat[m[Kch

1477+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K171[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1478+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K175[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1479+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K176[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1480+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K177[m[K[36m[K:[m[K:: ^^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1481+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K178[m[K[36m[K:[m[K:: ^^^^ meta.variable.substring.dos[1;33m[Kbat[m[Kch

1482+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K179[m[K[36m[K:[m[K:: ^ constant.numeric.dos[1;33m[Kbat[m[Kch

1483+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K180[m[K[36m[K:[m[K:: ^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1484+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K181[m[K[36m[K:[m[K:: ^^ constant.numeric.dos[1;33m[Kbat[m[Kch

1485+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K182[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1486+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K183[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1487+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K184[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1488+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K185[m[K[36m[K:[m[K:: ^^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1489+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K186[m[K[36m[K:[m[K:: ^^^^ meta.variable.substring.dos[1;33m[Kbat[m[Kch

1490+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K187[m[K[36m[K:[m[K:: ^ constant.numeric.dos[1;33m[Kbat[m[Kch

1491+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K188[m[K[36m[K:[m[K:: ^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1492+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K189[m[K[36m[K:[m[K:: ^^ constant.numeric.dos[1;33m[Kbat[m[Kch

1493+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K190[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1494+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K193[m[K[36m[K:[m[K:: ^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1495+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K194[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1496+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K195[m[K[36m[K:[m[K:: ^^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1497+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K196[m[K[36m[K:[m[K:: ^^ meta.variable.substring.dos[1;33m[Kbat[m[Kch

1498+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K197[m[K[36m[K:[m[K:: ^^ constant.numeric.dos[1;33m[Kbat[m[Kch

1499+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K198[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1500+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K199[m[K[36m[K:[m[K:: ^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1501+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K200[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1502+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K201[m[K[36m[K:[m[K:: ^^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1503+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K202[m[K[36m[K:[m[K:: ^^ meta.variable.substring.dos[1;33m[Kbat[m[Kch

1504+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K203[m[K[36m[K:[m[K:: ^^ constant.numeric.dos[1;33m[Kbat[m[Kch

1505+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K204[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1506+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K207[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^^^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1507+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K208[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1508+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K209[m[K[36m[K:[m[K:: ^^^^^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1509+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K210[m[K[36m[K:[m[K:: ^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1510+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K211[m[K[36m[K:[m[K:: ^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1511+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K212[m[K[36m[K:[m[K:: ^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1512+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K213[m[K[36m[K:[m[K:: ^^^^^^^^^^^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1513+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K214[m[K[36m[K:[m[K:: ^^^^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch meta.variable.substring.dos[1;33m[Kbat[m[Kch

1514+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K215[m[K[36m[K:[m[K:: ^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1515+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K216[m[K[36m[K:[m[K:: ^^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch constant.numeric.dos[1;33m[Kbat[m[Kch

1516+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K217[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1517+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K220[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1518+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K221[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1519+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K222[m[K[36m[K:[m[K:: ^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1520+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K223[m[K[36m[K:[m[K:: ^^^^^^^^^^^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1521+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K224[m[K[36m[K:[m[K:: ^^^^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch meta.variable.substring.dos[1;33m[Kbat[m[Kch

1522+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K225[m[K[36m[K:[m[K:: ^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1523+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K226[m[K[36m[K:[m[K:: ^^ meta.variable.substitution.dos[1;33m[Kbat[m[Kch constant.numeric.dos[1;33m[Kbat[m[Kch

1524+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K227[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1525+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K230[m[K[36m[K:[m[K:: ^^^^^^^^^^^^ - variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1526+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K231[m[K[36m[K:[m[K:: ^^^ - keyword.operator.logical.dos[1;33m[Kbat[m[Kch

1527+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K234[m[K[36m[K:[m[K:: ^^^^^^^^^^^^ - variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1528+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K235[m[K[36m[K:[m[K:: ^^^ - keyword.operator.logical.dos[1;33m[Kbat[m[Kch

1529+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K239[m[K[36m[K:[m[K:: ^^^ constant.numeric.integer.octal.dos[1;33m[Kbat[m[Kch

1530+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K240[m[K[36m[K:[m[K:: ^ punctuation.definition.numeric.octal.dos[1;33m[Kbat[m[Kch

1531+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K241[m[K[36m[K:[m[K:: ^^^^ constant.numeric.integer.hexadecimal.dos[1;33m[Kbat[m[Kch

1532+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K242[m[K[36m[K:[m[K:: ^^ punctuation.definition.numeric.hexadecimal.dos[1;33m[Kbat[m[Kch

1533+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K243[m[K[36m[K:[m[K:: ^^ constant.numeric.integer.decimal.dos[1;33m[Kbat[m[Kch

1534+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K247[m[K[36m[K:[m[K:: ^^ constant.character.escape.dos[1;33m[Kbat[m[Kch

1535+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K248[m[K[36m[K:[m[K:: ^^^ constant.character.escape.dos[1;33m[Kbat[m[Kch

1536+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K249[m[K[36m[K:[m[K:: ^^ constant.character.escape.dos[1;33m[Kbat[m[Kch

1537+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K253[m[K[36m[K:[m[K:: ^^^^^^^^^ meta.expression.set.dos[1;33m[Kbat[m[Kch

1538+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K254[m[K[36m[K:[m[K:: ^^^ keyword.operator.assignment.augmented.dos[1;33m[Kbat[m[Kch

1539+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K257[m[K[36m[K:[m[K:: ^^ keyword.operator.assignment.augmented.dos[1;33m[Kbat[m[Kch

1540+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K260[m[K[36m[K:[m[K:: ^^ keyword.operator.assignment.augmented.dos[1;33m[Kbat[m[Kch

1541+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K263[m[K[36m[K:[m[K:: ^^ keyword.operator.assignment.augmented.dos[1;33m[Kbat[m[Kch

1542+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K266[m[K[36m[K:[m[K:: ^^ keyword.operator.assignment.augmented.dos[1;33m[Kbat[m[Kch

1543+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K269[m[K[36m[K:[m[K:: ^^ keyword.operator.assignment.augmented.dos[1;33m[Kbat[m[Kch

1544+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K272[m[K[36m[K:[m[K:: ^^^ keyword.operator.assignment.augmented.dos[1;33m[Kbat[m[Kch

1545+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K275[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1546+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K276[m[K[36m[K:[m[K:: ^ keyword.operator.logical.dos[1;33m[Kbat[m[Kch

1547+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K279[m[K[36m[K:[m[K:: ^^^^^ meta.group.dos[1;33m[Kbat[m[Kch

1548+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K280[m[K[36m[K:[m[K:: ^ punctuation.section.group.begin.dos[1;33m[Kbat[m[Kch

1549+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K281[m[K[36m[K:[m[K:: ^ punctuation.section.group.end.dos[1;33m[Kbat[m[Kch

1550+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K282[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1551+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K283[m[K[36m[K:[m[K:: ^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1552+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K284[m[K[36m[K:[m[K:: ^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1553+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K287[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1554+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K288[m[K[36m[K:[m[K:: ^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1555+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K289[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1556+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K290[m[K[36m[K:[m[K:: ^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1557+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K293[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1558+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K294[m[K[36m[K:[m[K:: ^^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1559+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K297[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1560+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K298[m[K[36m[K:[m[K:: ^^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1561+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K301[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1562+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K302[m[K[36m[K:[m[K:: ^^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1563+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K305[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1564+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K306[m[K[36m[K:[m[K:: ^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1565+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K309[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1566+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K310[m[K[36m[K:[m[K:: ^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1567+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K313[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1568+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K314[m[K[36m[K:[m[K:: ^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1569+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K317[m[K[36m[K:[m[K:: ^^ keyword.operator.assignment.augmented.dos[1;33m[Kbat[m[Kch

1570+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K320[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1571+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K321[m[K[36m[K:[m[K:: ^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1572+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K324[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1573+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K325[m[K[36m[K:[m[K:: ^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1574+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K328[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1575+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K329[m[K[36m[K:[m[K:: ^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1576+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K332[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1577+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K333[m[K[36m[K:[m[K:: ^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1578+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K336[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1579+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K337[m[K[36m[K:[m[K:: ^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1580+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K340[m[K[36m[K:[m[K:: ^^^ keyword.operator.assignment.augmented.dos[1;33m[Kbat[m[Kch

1581+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K343[m[K[36m[K:[m[K:: ^^ keyword.operator.assignment.augmented.dos[1;33m[Kbat[m[Kch

1582+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K346[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1583+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K347[m[K[36m[K:[m[K:: ^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1584+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K348[m[K[36m[K:[m[K:: ^ punctuation.separator.dos[1;33m[Kbat[m[Kch

1585+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K349[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1586+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K350[m[K[36m[K:[m[K:: ^ keyword.operator.arithmetic.dos[1;33m[Kbat[m[Kch

1587+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K436[m[K[36m[K:[m[K:: ^^^^^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1588+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K444[m[K[36m[K:[m[K:: ^^^^^^^^^^^ string.quoted.double.dos[1;33m[Kbat[m[Kch

1589+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K445[m[K[36m[K:[m[K:: ^^ constant.character.escape.dos[1;33m[Kbat[m[Kch

1590+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K446[m[K[36m[K:[m[K:: ^ - constant.character.escape.dos[1;33m[Kbat[m[Kch

1591+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K447[m[K[36m[K:[m[K:: ^^ constant.character.escape.dos[1;33m[Kbat[m[Kch

1592+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K448[m[K[36m[K:[m[K:: ^ - constant.character.escape.dos[1;33m[Kbat[m[Kch

1593+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K449[m[K[36m[K:[m[K:: ^^ constant.character.escape.dos[1;33m[Kbat[m[Kch

1594+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K450[m[K[36m[K:[m[K:: ^ - constant.character.escape.dos[1;33m[Kbat[m[Kch

1595+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K454[m[K[36m[K:[m[K:: ^^^^ - variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1596+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K455[m[K[36m[K:[m[K:: ^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1597+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K456[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1598+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K457[m[K[36m[K:[m[K:: ^ keyword.operator.redirection.dos[1;33m[Kbat[m[Kch

1599+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K459[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.begin.dos[1;33m[Kbat[m[Kch

1600+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K460[m[K[36m[K:[m[K:: ^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1601+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K461[m[K[36m[K:[m[K:: ^ punctuation.definition.variable.end.dos[1;33m[Kbat[m[Kch

1602+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K464[m[K[36m[K:[m[K:: ^^^^ - variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1603+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K465[m[K[36m[K:[m[K:: ^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1604+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K466[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1605+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K467[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^ meta.prompt.set.dos[1;33m[Kbat[m[Kch string.unquoted - variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1606+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K468[m[K[36m[K:[m[K:: ^ - meta.prompt.set.dos[1;33m[Kbat[m[Kch

1607+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K470[m[K[36m[K:[m[K:: ^^^^ - variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1608+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K471[m[K[36m[K:[m[K:: ^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1609+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K472[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1610+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K473[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prompt.set.dos[1;33m[Kbat[m[Kch string.unquoted - variable.other.readwrite.dos[1;33m[Kbat[m[Kch - comment

1611+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K474[m[K[36m[K:[m[K:: ^ - meta.prompt.set.dos[1;33m[Kbat[m[Kch

1612+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K476[m[K[36m[K:[m[K:: ^^^^ - variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1613+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K477[m[K[36m[K:[m[K:: ^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1614+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K478[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1615+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K479[m[K[36m[K:[m[K:: ^ - meta.prompt.set.dos[1;33m[Kbat[m[Kch

1616+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K493[m[K[36m[K:[m[K:: ^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1617+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K494[m[K[36m[K:[m[K:: ^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1618+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K498[m[K[36m[K:[m[K:: ^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1619+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K499[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1620+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K500[m[K[36m[K:[m[K:: ^ punctuation.definition.string.begin.dos[1;33m[Kbat[m[Kch

1621+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K501[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ string.quoted.double.dos[1;33m[Kbat[m[Kch

1622+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K502[m[K[36m[K:[m[K:: ^^^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1623+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K503[m[K[36m[K:[m[K:: ^^ constant.character.escape.dos[1;33m[Kbat[m[Kch

1624+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K504[m[K[36m[K:[m[K:: ^ punctuation.definition.string.end.dos[1;33m[Kbat[m[Kch

1625+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K505[m[K[36m[K:[m[K:: ^^^ string.unquoted.dos[1;33m[Kbat[m[Kch

1626+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K508[m[K[36m[K:[m[K::^^^^^^ keyword.command.dos[1;33m[Kbat[m[Kch

1627+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K510[m[K[36m[K:[m[K:: ^^^^ - variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1628+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K511[m[K[36m[K:[m[K:: ^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1629+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K512[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch

1630+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K513[m[K[36m[K:[m[K:: ^ punctuation.definition.string.begin.dos[1;33m[Kbat[m[Kch

1631+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K514[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prompt.set.dos[1;33m[Kbat[m[Kch string.quoted

1632+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K515[m[K[36m[K:[m[K:: ^ punctuation.definition.string.end.dos[1;33m[Kbat[m[Kch

1633+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K516[m[K[36m[K:[m[K:: ^ keyword.operator.conditional.dos[1;33m[Kbat[m[Kch - meta.prompt.set.dos[1;33m[Kbat[m[Kch - string

1634+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K517[m[K[36m[K:[m[K:: ^^^^ keyword.command.dos[1;33m[Kbat[m[Kch

1635+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K518[m[K[36m[K:[m[K:: ^^^^^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1636+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K520[m[K[36m[K:[m[K::^^^^^^ keyword.command.dos[1;33m[Kbat[m[Kch

1637+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K542[m[K[36m[K:[m[K:: ^^^^ - variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1638+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K543[m[K[36m[K:[m[K:: ^^^^^ variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1639+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K544[m[K[36m[K:[m[K:: ^ keyword.operator.assignment.dos[1;33m[Kbat[m[Kch - variable.other.readwrite.dos[1;33m[Kbat[m[Kch

1640+[35m[Kassets/syntaxes/01_Packages/Batch File/syntax_test_batch_file.bat[m[K[36m[K:[m[K[32m[K545[m[K[36m[K:[m[K:: ^^^^^^^^^^^^^^^^ meta.prompt.set.dos[1;33m[Kbat[m[Kch string.quoted - variable.other.readwrite.dos[1;33m[Kbat[m[Kch - comment

1641+[35m[Kassets/syntaxes/01_Packages/CSS/CSS.sublime-syntax[m[K[36m[K:[m[K[32m[K1257[m[K[36m[K:[m[K - match: '\[1;33m[Kbat[m[K\b'

1642+[35m[Kassets/syntaxes/01_Packages/C#/tests/syntax_test_Strings.cs[m[K[36m[K:[m[K[32m[K35[m[K[36m[K:[m[Kvar ver[1;33m[Kbat[m[Kim_singleline = @"foo";

1643+[35m[Kassets/syntaxes/01_Packages/C#/tests/syntax_test_Strings.cs[m[K[36m[K:[m[K[32m[K37[m[K[36m[K:[m[Kvar ver[1;33m[Kbat[m[Kim_singleline_interpolated_none = $@"foo bar";

1644+[35m[Kassets/syntaxes/01_Packages/C#/tests/syntax_test_Strings.cs[m[K[36m[K:[m[K[32m[K39[m[K[36m[K:[m[Kvar ver[1;33m[Kbat[m[Kim_singleline_interpolated_yes = $@"foo {bar} foo";

1645+[35m[Kassets/syntaxes/01_Packages/C#/tests/syntax_test_Strings.cs[m[K[36m[K:[m[K[32m[K42[m[K[36m[K:[m[Kvar ver[1;33m[Kbat[m[Kim_multiline = @"foo bar

1646+[35m[Kassets/syntaxes/01_Packages/C#/tests/syntax_test_Strings.cs[m[K[36m[K:[m[K[32m[K45[m[K[36m[K:[m[Kvar ver[1;33m[Kbat[m[Kim_multiline_interpolated_none = $@"foo bar

1647+[35m[Kassets/syntaxes/01_Packages/C#/tests/syntax_test_Strings.cs[m[K[36m[K:[m[K[32m[K48[m[K[36m[K:[m[Kvar ver[1;33m[Kbat[m[Kim_multiline_interpolated_yes = $@"foo {bar}

1648+[35m[Kassets/syntaxes/01_Packages/C#/tests/syntax_test_GeneralStructure.cs[m[K[36m[K:[m[K[32m[K344[m[K[36m[K:[m[K case BLBody[1;33m[KBat[m[KtleLibrary.ContextType.TapUp:

1649+[35m[Kassets/syntaxes/01_Packages/C#/tests/syntax_test_Generics.cs[m[K[36m[K:[m[K[32m[K57[m[K[36m[K:[m[Kstring ver[1;33m[Kbat[m[Kim = @"This is a test "" of a ver[1;33m[Kbat[m[Kim string literal - C:\User";

1650+[35m[Kassets/syntaxes/01_Packages/C#/tests/syntax_test_c#.cs[m[K[36m[K:[m[K[32m[K35[m[K[36m[K:[m[Kstring ver[1;33m[Kbat[m[Kim = @"This is a test "" of a ver[1;33m[Kbat[m[Kim string literal - C:\User";

1651+[35m[Kassets/syntaxes/01_Packages/PHP/PHP.sublime-completions[m[K[36m[K:[m[K[32m[K2082[m[K[36m[K:[m[K { "trigger": "mssql_fetch_[1;33m[Kbat[m[Kch", "contents": "mssql_fetch_[1;33m[Kbat[m[Kch(${1:result})" },

1652+[35m[Kassets/syntaxes/01_Packages/PHP/PHP Source.sublime-syntax[m[K[36m[K:[m[K[32m[K407[m[K[36m[K:[m[K # ver[1;33m[Kbat[m[Kim and the indexer should find the name in the original source

1653+[35m[Kassets/syntaxes/01_Packages/PHP/PHP Source.sublime-syntax[m[K[36m[K:[m[K[32m[K447[m[K[36m[K:[m[K # ver[1;33m[Kbat[m[Kim and the indexer should find the name in the original source

1655+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K29[m[K[36m[K:[m[K - include: ver[1;33m[Kbat[m[Kim

1656+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K311[m[K[36m[K:[m[K ver[1;33m[Kbat[m[Kim:

1657+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K312[m[K[36m[K:[m[K - match: '((\\)begin)(\{)\s*((?:[vV]er[1;33m[Kbat[m[Kim|alltt)\*?)\s*(\})'

1658+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K321[m[K[36m[K:[m[K - meta_scope: meta.environment.ver[1;33m[Kbat[m[Kim.ver[1;33m[Kbat[m[Kim.latex

1659+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K322[m[K[36m[K:[m[K - meta_content_scope: markup.raw.ver[1;33m[Kbat[m[Kim.latex

1660+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K541[m[K[36m[K:[m[K - meta_scope: meta.environment.ver[1;33m[Kbat[m[Kim.verb.latex

1661+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K777[m[K[36m[K:[m[K - meta_scope: meta.environment.ver[1;33m[Kbat[m[Kim.lstinline.latex

1662+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K784[m[K[36m[K:[m[K - meta_content_scope: meta.environment.ver[1;33m[Kbat[m[Kim.lstinline.latex markup.raw.verb.latex

1663+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K786[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.lstinline.latex punctuation.definition.group.brace.end.latex

1664+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K792[m[K[36m[K:[m[K - meta_content_scope: meta.environment.ver[1;33m[Kbat[m[Kim.lstinline.latex markup.raw.verb.latex

1665+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K794[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.lstinline.latex punctuation.definition.verb.latex

1666+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K806[m[K[36m[K:[m[K - meta_scope: meta.environment.ver[1;33m[Kbat[m[Kim.lstlisting.latex

1667+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K938[m[K[36m[K:[m[K - meta_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1668+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1146[m[K[36m[K:[m[K - meta_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1669+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1149[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1670+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1157[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.c.latex source.c.embedded

1671+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1163[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1672+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1171[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.c++.latex source.c++.embedded

1673+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1177[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1674+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1185[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.diff.latex source.diff.embedded

1675+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1191[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1676+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1199[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.go.latex source.go.embedded

1677+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1205[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1678+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1213[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.haskell.latex source.haskell.embedded

1679+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1219[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1680+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1227[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.html.latex text.html.embedded

1681+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1233[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1682+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1241[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.java.latex source.java.embedded

1683+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1247[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1684+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1255[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.js.latex source.js.embedded

1685+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1261[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1686+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1269[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.json.latex source.json.embedded

1687+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1275[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1688+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1283[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.latex.latex text.tex.latex.embedded

1689+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1289[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1690+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1297[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.lisp.latex source.lisp.embedded

1691+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1303[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1692+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1311[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.lua.latex source.lua.embedded

1693+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1317[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1694+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1325[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.objc.latex source.objc.embedded

1695+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1331[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1696+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1339[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.objc++.latex source.objc++.embedded

1697+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1345[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1698+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1353[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.perl.latex source.perl.embedded

1699+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1359[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1700+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1367[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.php.latex source.php.embedded

1701+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1373[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1702+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1381[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.python.latex source.python.embedded

1703+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1387[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1704+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1395[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.r.latex source.r.embedded

1705+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1401[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1706+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1409[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.ruby.latex source.ruby.embedded

1707+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1415[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1708+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1423[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.shell.latex source.shell.embedded

1709+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1429[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1710+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1437[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.sql.latex source.sql.embedded

1711+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1443[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1712+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1451[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.xml.latex text.xml.embedded

1713+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1457[m[K[36m[K:[m[K scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1714+[35m[Kassets/syntaxes/01_Packages/LaTeX/LaTeX.sublime-syntax[m[K[36m[K:[m[K[32m[K1465[m[K[36m[K:[m[K embed_scope: meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex meta.environment.embedded.yaml.latex source.yaml.embedded

1715+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K261[m[K[36m[K:[m[K% VER[1;33m[KBAT[m[KIM

1716+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K267[m[K[36m[K:[m[K% ^ meta.environment.ver[1;33m[Kbat[m[Kim.verb.latex

1717+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K271[m[K[36m[K:[m[K% ^ meta.environment.ver[1;33m[Kbat[m[Kim.verb.latex

1718+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K274[m[K[36m[K:[m[K% ^^^^^^^^^^^^^^ meta.environment.ver[1;33m[Kbat[m[Kim.verb.latex

1719+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K277[m[K[36m[K:[m[K% <- - meta.environment.ver[1;33m[Kbat[m[Kim.verb.latex

1720+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K279[m[K[36m[K:[m[K\begin{ver[1;33m[Kbat[m[Kim}

1721+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K282[m[K[36m[K:[m[KThe \emph{ver[1;33m[Kbat[m[Kim} environment sets everything in ver[1;33m[Kbat[m[Kim.

1722+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K283[m[K[36m[K:[m[K% <- meta.environment.ver[1;33m[Kbat[m[Kim.ver[1;33m[Kbat[m[Kim.latex

1723+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K284[m[K[36m[K:[m[K% ^ markup.raw.ver[1;33m[Kbat[m[Kim.latex

1724+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K290[m[K[36m[K:[m[K\end{ver[1;33m[Kbat[m[Kim}

1725+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K397[m[K[36m[K:[m[K% <- meta.environment.ver[1;33m[Kbat[m[Kim.lstlisting.latex

1726+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K407[m[K[36m[K:[m[K% <- meta.environment.ver[1;33m[Kbat[m[Kim.lstlisting.latex

1727+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K415[m[K[36m[K:[m[K% <- meta.environment.ver[1;33m[Kbat[m[Kim.lstlisting.latex

1728+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K423[m[K[36m[K:[m[K% ^^^^^^^^^^^^^^^^^^^^^ meta.environment.ver[1;33m[Kbat[m[Kim.lstinline.latex

1729+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K428[m[K[36m[K:[m[K% ^ - meta.environment.ver[1;33m[Kbat[m[Kim.lstinline.latex

1730+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K431[m[K[36m[K:[m[K% ^^^^^^^^^^^^^^^^^^^^^ meta.environment.ver[1;33m[Kbat[m[Kim.lstinline.latex

1731+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K433[m[K[36m[K:[m[K% ^ - meta.environment.ver[1;33m[Kbat[m[Kim.lstinline.latex

1732+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K443[m[K[36m[K:[m[K% <- meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1733+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K451[m[K[36m[K:[m[K% ^ meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1734+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K459[m[K[36m[K:[m[K% ^ meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1735+[35m[Kassets/syntaxes/01_Packages/LaTeX/syntax_test_latex.tex[m[K[36m[K:[m[K[32m[K464[m[K[36m[K:[m[K% ^ meta.environment.ver[1;33m[Kbat[m[Kim.minted.latex

1736+[35m[Kassets/syntaxes/01_Packages/Java/Ant.sublime-build[m[K[36m[K:[m[K[32m[K10[m[K[36m[K:[m[K "cmd": ["ant.[1;33m[Kbat[m[K"]

1738+[35m[Kassets/syntaxes/01_Packages/RestructuredText/reStructuredText.sublime-syntax[m[K[36m[K:[m[K[32m[K41[m[K[36m[K:[m[K comment: ver[1;33m[Kbat[m[Kim blocks

1739+[35m[Kassets/syntaxes/01_Packages/RestructuredText/syntax_test_restructuredtext.rst[m[K[36m[K:[m[K[32m[K95[m[K[36m[K:[m[KVer[1;33m[Kbat[m[Kim tests

1740+[35m[Kassets/syntaxes/01_Packages/RestructuredText/syntax_test_restructuredtext.rst[m[K[36m[K:[m[K[32m[K100[m[K[36m[K:[m[K Ver[1;33m[Kbat[m[Kim

1741+[35m[Kassets/syntaxes/01_Packages/RestructuredText/syntax_test_restructuredtext.rst[m[K[36m[K:[m[K[32m[K105[m[K[36m[K:[m[K Ver[1;33m[Kbat[m[Kim

1742+[35m[Kassets/syntaxes/01_Packages/RestructuredText/syntax_test_restructuredtext.rst[m[K[36m[K:[m[K[32m[K112[m[K[36m[K:[m[K Ver[1;33m[Kbat[m[Kim

1743+[35m[Kassets/syntaxes/01_Packages/RestructuredText/syntax_test_restructuredtext.rst[m[K[36m[K:[m[K[32m[K114[m[K[36m[K:[m[K Also Ver[1;33m[Kbat[m[Kim

1744+[35m[Kassets/syntaxes/01_Packages/RestructuredText/syntax_test_restructuredtext.rst[m[K[36m[K:[m[K[32m[K119[m[K[36m[K:[m[K Ver[1;33m[Kbat[m[Kim

1745+[35m[Kassets/syntaxes/01_Packages/RestructuredText/syntax_test_restructuredtext.rst[m[K[36m[K:[m[K[32m[K121[m[K[36m[K:[m[K Also Ver[1;33m[Kbat[m[Kim

1746+[35m[Kassets/syntaxes/01_Packages/RestructuredText/syntax_test_restructuredtext.rst[m[K[36m[K:[m[K[32m[K127[m[K[36m[K:[m[K Ver[1;33m[Kbat[m[Kim

1747+[35m[Kassets/syntaxes/01_Packages/RestructuredText/syntax_test_restructuredtext.rst[m[K[36m[K:[m[K[32m[K129[m[K[36m[K:[m[KNot ver[1;33m[Kbat[m[Kim

1748+[35m[Kassets/syntaxes/01_Packages/Go/Indents/GoIndent.tmPreferences[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K[1;33m[Kbat[m[Kch-reindent real-world code without wrecking it. As such, these rules are

1749+[35m[Kassets/syntaxes/01_Packages/Go/Indents/GoIndent.tmPreferences[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[Koptimized for convenience while typing, not for [1;33m[Kbat[m[Kch reindentation.

1750+[35m[Kassets/syntaxes/01_Packages/YAML/YAML.sublime-syntax[m[K[36m[K:[m[K[32m[K64[m[K[36m[K:[m[K c_ns_tag_property: |- # c-ver[1;33m[Kbat[m[Kim-tag | c-ns-shorthand-tag | c-non-specific-tag

1751+[35m[Kassets/manual/bat.1.in[m[K[36m[K:[m[K[32m[K113[m[K[36m[K:[m[K\fB-P\fR. To disable the pager permanently, set [1;33m[KBAT[m[K_PAGER to an empty string. To control

1752+[35m[Kassets/manual/bat.1.in[m[K[36m[K:[m[K[32m[K118[m[K[36m[K:[m[KDetermine which pager is used. This option will override the PAGER and [1;33m[KBAT[m[K_PAGER

1753+[35m[Kassets/manual/bat.1.in[m[K[36m[K:[m[K[32m[K134[m[K[36m[K:[m[Kexport the [1;33m[KBAT[m[K_THEME environment variable (e.g.: export [1;33m[KBAT[m[K_THEME="...").

1754+[35m[Kassets/manual/bat.1.in[m[K[36m[K:[m[K[32m[K146[m[K[36m[K:[m[Kexport the [1;33m[KBAT[m[K_STYLE environment variable (e.g.: export [1;33m[KBAT[m[K_STYLE=".."). Possible

1755+[35m[Kassets/manual/bat.1.in[m[K[36m[K:[m[K[32m[K194[m[K[36m[K:[m[KAlternatively, you can use the [1;33m[KBAT[m[K_CONFIG_PATH environment variable to point {{PROJECT_EXECUTABLE}} to a non-default

1756+[35m[Kassets/manual/bat.1.in[m[K[36m[K:[m[K[32m[K235[m[K[36m[K:[m[K\fBhttps://github.com/sharkdp/[1;33m[Kbat[m[K\fR

1757+[35m[Kassets/completions/bat.bash.in[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K_[1;33m[Kbat[m[K() {

1758+[35m[Kassets/completions/bat.bash.in[m[K[36m[K:[m[K[32m[K88[m[K[36m[K:[m[K} && complete -F _[1;33m[Kbat[m[K {{PROJECT_EXECUTABLE}}

1759+[35m[Kassets/completions/_bat.ps1.in[m[K[36m[K:[m[K[32m[K64[m[K[36m[K:[m[K [CompletionResult]::new('--config-dir', 'config-dir', [CompletionResultType]::ParameterName, 'Show [1;33m[Kbat[m[K''s configuration directory.')

1760+[35m[Kassets/completions/_bat.ps1.in[m[K[36m[K:[m[K[32m[K65[m[K[36m[K:[m[K [CompletionResult]::new('--cache-dir', 'cache-dir', [CompletionResultType]::ParameterName, 'Show [1;33m[Kbat[m[K''s cache directory.')

1761+[35m[Kassets/completions/bat.zsh.in[m[K[36m[K:[m[K[32m[K49[m[K[36m[K:[m[K '(: --config-dir)'--config-dir'[Show [1;33m[Kbat[m[K'"'"'s configuration directory]'

1762+[35m[Kassets/completions/bat.zsh.in[m[K[36m[K:[m[K[32m[K52[m[K[36m[K:[m[K '(: --cache-dir)'--cache-dir'[Show [1;33m[Kbat[m[K'"'"'s cache directory]'

1763+[35m[Kassets/create.sh[m[K[36m[K:[m[K[32m[K43[m[K[36m[K:[m[K[1;33m[Kbat[m[K cache --clear

1764+[35m[Kassets/create.sh[m[K[36m[K:[m[K[32m[K56[m[K[36m[K:[m[K[1;33m[Kbat[m[K cache --build --blank --source="$ASSET_DIR" --target="$ASSET_DIR"

1765+[35m[Kassets/metadata.yaml[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[K[1;33m[Kbat[m[K_version: 0.18.3

1766+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K34[m[K[36m[K:[m[Kfn [1;33m[Kbat[m[K_raw_command_with_config() -> Command {

1767+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K35[m[K[36m[K:[m[K let mut cmd = Command::cargo_bin("[1;33m[Kbat[m[K").unwrap();

1768+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K37[m[K[36m[K:[m[K cmd.env_remove("[1;33m[KBAT[m[K_CACHE_PATH");

1769+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K38[m[K[36m[K:[m[K cmd.env_remove("[1;33m[KBAT[m[K_CONFIG_DIR");

1770+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K39[m[K[36m[K:[m[K cmd.env_remove("[1;33m[KBAT[m[K_CONFIG_PATH");

1771+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K40[m[K[36m[K:[m[K cmd.env_remove("[1;33m[KBAT[m[K_OPTS");

1772+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K41[m[K[36m[K:[m[K cmd.env_remove("[1;33m[KBAT[m[K_PAGER");

1773+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K42[m[K[36m[K:[m[K cmd.env_remove("[1;33m[KBAT[m[K_STYLE");

1774+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K43[m[K[36m[K:[m[K cmd.env_remove("[1;33m[KBAT[m[K_TABS");

1775+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K44[m[K[36m[K:[m[K cmd.env_remove("[1;33m[KBAT[m[K_THEME");

1776+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K51[m[K[36m[K:[m[Kfn [1;33m[Kbat[m[K_raw_command() -> Command {

1777+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K52[m[K[36m[K:[m[K let mut cmd = [1;33m[Kbat[m[K_raw_command_with_config();

1778+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K57[m[K[36m[K:[m[Kfn [1;33m[Kbat[m[K_with_config() -> assert_cmd::Command {

1779+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K58[m[K[36m[K:[m[K assert_cmd::Command::from_std([1;33m[Kbat[m[K_raw_command_with_config())

1780+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K61[m[K[36m[K:[m[Kfn [1;33m[Kbat[m[K() -> assert_cmd::Command {

1781+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K62[m[K[36m[K:[m[K assert_cmd::Command::from_std([1;33m[Kbat[m[K_raw_command())

1782+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K67[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1783+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K77[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1784+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K86[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1785+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K96[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1786+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K108[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1787+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K118[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1788+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K128[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1789+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K138[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1790+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K149[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1791+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K160[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1792+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K170[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1793+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K181[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1794+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K192[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1795+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K202[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1796+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K212[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1797+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K222[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1798+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K245[m[K[36m[K:[m[K let res = [1;33m[Kbat[m[K_raw_command()

1799+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K261[m[K[36m[K:[m[K let res = [1;33m[Kbat[m[K_raw_command()

1800+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K277[m[K[36m[K:[m[K let res = [1;33m[Kbat[m[K_raw_command()

1801+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K293[m[K[36m[K:[m[K let res = [1;33m[Kbat[m[K_raw_command()

1802+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K307[m[K[36m[K:[m[K // To simulate [1;33m[Kbat[m[K getting started from the shell, a process is created with stdin and stdout

1803+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K308[m[K[36m[K:[m[K // as the slave end of a pseudo terminal. Although both point to the same "file", [1;33m[Kbat[m[K should

1804+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K316[m[K[36m[K:[m[K let mut child = [1;33m[Kbat[m[K_raw_command()

1805+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K349[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1806+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K372[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1807+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K395[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1808+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K418[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1809+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K441[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1810+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K464[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1811+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K487[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1812+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K510[m[K[36m[K:[m[K [1;33m[Kbat[m[K().arg("non-existing-file").assert().failure();

1813+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K515[m[K[36m[K:[m[K [1;33m[Kbat[m[K().arg("sub_directory").assert().failure();

1814+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K520[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1815+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K530[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1816+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K541[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1817+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K543[m[K[36m[K:[m[K .env("[1;33m[KBAT[m[K_PAGER", "echo pager-output")

1818+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K553[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1819+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K555[m[K[36m[K:[m[K .env("[1;33m[KBAT[m[K_PAGER", "")

1820+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K564[m[K[36m[K:[m[Kfn env_var_pager_value_[1;33m[Kbat[m[K() {

1821+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K565[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1822+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K566[m[K[36m[K:[m[K .env("PAGER", "[1;33m[Kbat[m[K")

1823+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K575[m[K[36m[K:[m[Kfn env_var_[1;33m[Kbat[m[K_pager_value_[1;33m[Kbat[m[K() {

1824+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K576[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1825+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K577[m[K[36m[K:[m[K .env("[1;33m[KBAT[m[K_PAGER", "[1;33m[Kbat[m[K")

1826+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K582[m[K[36m[K:[m[K .stderr(predicate::str::contains("[1;33m[Kbat[m[K as a pager is disallowed"));

1827+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K586[m[K[36m[K:[m[Kfn pager_value_[1;33m[Kbat[m[K() {

1828+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K587[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1829+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K588[m[K[36m[K:[m[K .arg("--pager=[1;33m[Kbat[m[K")

1830+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K593[m[K[36m[K:[m[K .stderr(predicate::str::contains("[1;33m[Kbat[m[K as a pager is disallowed"));

1831+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K603[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1832+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K613[m[K[36m[K:[m[K/// If the [1;33m[Kbat[m[K-specific [1;33m[KBAT[m[K_PAGER is used, obey the wish of the user

1833+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K617[m[K[36m[K:[m[Kfn pager_most_from_[1;33m[Kbat[m[K_pager_env_var() {

1834+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K619[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1835+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K620[m[K[36m[K:[m[K .env("[1;33m[KBAT[m[K_PAGER", mocked_pagers::from("most"))

1836+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K629[m[K[36m[K:[m[K/// Same reasoning with --pager as with [1;33m[KBAT[m[K_PAGER

1837+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K634[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1838+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K649[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1839+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K664[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1840+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K676[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1841+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K687[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1842+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K699[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1843+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K700[m[K[36m[K:[m[K .env("[1;33m[KBAT[m[K_PAGER", "mismatched-quotes 'a")

1844+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K710[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1845+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K714[m[K[36m[K:[m[K .stdout(predicate::str::contains("[1;33m[KBAT[m[K_PAGER="))

1846+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K720[m[K[36m[K:[m[K [1;33m[Kbat[m[K_with_config()

1847+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K721[m[K[36m[K:[m[K .env("[1;33m[KBAT[m[K_CONFIG_PATH", "[1;33m[Kbat[m[K.conf")

1848+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K725[m[K[36m[K:[m[K .stdout("[1;33m[Kbat[m[K.conf\n");

1849+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K727[m[K[36m[K:[m[K [1;33m[Kbat[m[K_with_config()

1850+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K728[m[K[36m[K:[m[K .env("[1;33m[KBAT[m[K_CONFIG_PATH", "not-existing.conf")

1851+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K740[m[K[36m[K:[m[K // Create the file with [1;33m[Kbat[m[K

1852+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K741[m[K[36m[K:[m[K [1;33m[Kbat[m[K_with_config()

1853+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K742[m[K[36m[K:[m[K .env("[1;33m[KBAT[m[K_CONFIG_PATH", tmp_config_path.to_str().unwrap())

1854+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K756[m[K[36m[K:[m[Kfn config_location_from_[1;33m[Kbat[m[K_config_dir_variable() {

1855+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K757[m[K[36m[K:[m[K [1;33m[Kbat[m[K_with_config()

1856+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K758[m[K[36m[K:[m[K .env("[1;33m[KBAT[m[K_CONFIG_DIR", "conf/")

1857+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K767[m[K[36m[K:[m[K [1;33m[Kbat[m[K_with_config()

1858+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K768[m[K[36m[K:[m[K .env("[1;33m[KBAT[m[K_CONFIG_PATH", "[1;33m[Kbat[m[K.conf")

1859+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K778[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1860+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K789[m[K[36m[K:[m[K [1;33m[Kbat[m[K_with_config()

1861+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K799[m[K[36m[K:[m[K [1;33m[Kbat[m[K_with_config()

1862+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K810[m[K[36m[K:[m[K [1;33m[Kbat[m[K_with_config()

1863+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K820[m[K[36m[K:[m[K [1;33m[Kbat[m[K_with_config().arg("cach").assert().failure();

1864+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K827[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1865+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K836[m[K[36m[K:[m[K [1;33m[Kbat[m[K_with_config()

1866+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K878[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1867+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K898[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1868+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K910[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1869+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K922[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1870+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K936[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1871+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K950[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1872+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K966[m[K[36m[K:[m[K [1;33m[Kbat[m[K_with_config()

1873+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K979[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1874+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K995[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1875+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1008[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1876+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1020[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1877+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1040[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1878+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1057[m[K[36m[K:[m[K .stderr("\x1b[33m[[1;33m[Kbat[m[K warning]\x1b[0m: Style 'rule' is a subset of style 'grid', 'rule' will not be visible.\n");

1879+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1077[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1880+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1093[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1881+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1105[m[K[36m[K:[m[K let cmd_for_file = [1;33m[Kbat[m[K()

1882+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1114[m[K[36m[K:[m[K let cmd_for_stdin = [1;33m[Kbat[m[K()

1883+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1134[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1884+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1147[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1885+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1157[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1886+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1169[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1887+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1181[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1888+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1193[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1889+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1204[m[K[36m[K:[m[K// Regression test for https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/299

1890+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1207[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1891+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1231[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1892+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1240[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1893+[35m[Ktests/integration_tests.rs[m[K[36m[K:[m[K[32m[K1250[m[K[36m[K:[m[K [1;33m[Kbat[m[K()

1894+[35m[Ktests/examples/regression_tests/issue_985.js[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K# [1;33m[Kbat[m[K --map-syntax '*.js:Markdown' --file-name 'issue_985.js' < issue_985.js

1895+[35m[Ktests/examples/regression_tests/issue_985.js[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K# [1;33m[Kbat[m[K --map-syntax '*.js:Markdown' --file-name 'issue_985.js' issue_985.js

1896+[35m[Ktests/utils/mocked_pagers.rs[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[K/// On Windows: 'most' -> 'most.[1;33m[Kbat[m[K'

1897+[35m[Ktests/utils/mocked_pagers.rs[m[K[36m[K:[m[K[32m[K19[m[K[36m[K:[m[K format!("{}.[1;33m[Kbat[m[K", base)

1898+[35m[Ktests/benchmarks/benchmark-results/syntax-highlighting-speed-miniz.c.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K| `[1;33m[Kbat[m[K … miniz.c` | 96.2 ± 1.9 | 92.6 | 99.6 | 1.00 |

1899+[35m[Ktests/benchmarks/benchmark-results/syntax-highlighting-speed-jquery.js.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K| `[1;33m[Kbat[m[K … jquery.js` | 692.4 ± 5.6 | 684.2 | 701.8 | 1.00 |

1900+[35m[Ktests/benchmarks/benchmark-results/syntax-highlighting-speed-test_multiarray.py.json[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K "command": "[1;33m[Kbat[m[K … test_multiarray.py",

1901+[35m[Ktests/benchmarks/benchmark-results/syntax-highlighting-speed-jquery.js.json[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K "command": "[1;33m[Kbat[m[K … jquery.js",

1902+[35m[Ktests/benchmarks/benchmark-results/plain-text-speed.json[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K "command": "[1;33m[Kbat[m[K … --language=txt test_multiarray.py",

1903+[35m[Ktests/benchmarks/benchmark-results/syntax-highlighting-speed-test_multiarray.ansi-sequences.txt.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K| `[1;33m[Kbat[m[K … test_multiarray.ansi-sequences.txt` | 125.3 ± 5.6 | 119.3 | 140.4 | 1.00 |

1904+[35m[Ktests/benchmarks/benchmark-results/syntax-highlighting-speed-test_multiarray.py.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K| `[1;33m[Kbat[m[K … test_multiarray.py` | 924.7 ± 4.4 | 917.1 | 932.3 | 1.00 |

1905+[35m[Ktests/benchmarks/benchmark-results/report.md[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K## `[1;33m[Kbat[m[K` benchmark results

1906+[35m[Ktests/benchmarks/benchmark-results/report.md[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K| `[1;33m[Kbat[m[K` | 6.9 ± 0.6 | 5.6 | 9.2 | 1.00 |

1907+[35m[Ktests/benchmarks/benchmark-results/report.md[m[K[36m[K:[m[K[32m[K13[m[K[36m[K:[m[K| `[1;33m[Kbat[m[K … --language=txt test_multiarray.py` | 10.4 ± 0.6 | 9.0 | 12.1 | 1.00 |

1908+[35m[Ktests/benchmarks/benchmark-results/report.md[m[K[36m[K:[m[K[32m[K19[m[K[36m[K:[m[K| `[1;33m[Kbat[m[K … jquery.js` | 692.4 ± 5.6 | 684.2 | 701.8 | 1.00 |

1909+[35m[Ktests/benchmarks/benchmark-results/report.md[m[K[36m[K:[m[K[32m[K25[m[K[36m[K:[m[K| `[1;33m[Kbat[m[K … miniz.c` | 96.2 ± 1.9 | 92.6 | 99.6 | 1.00 |

1910+[35m[Ktests/benchmarks/benchmark-results/report.md[m[K[36m[K:[m[K[32m[K31[m[K[36m[K:[m[K| `[1;33m[Kbat[m[K … test_multiarray.ansi-sequences.txt` | 125.3 ± 5.6 | 119.3 | 140.4 | 1.00 |

1911+[35m[Ktests/benchmarks/benchmark-results/report.md[m[K[36m[K:[m[K[32m[K37[m[K[36m[K:[m[K| `[1;33m[Kbat[m[K … test_multiarray.py` | 924.7 ± 4.4 | 917.1 | 932.3 | 1.00 |

1912+[35m[Ktests/benchmarks/benchmark-results/startup-time.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K| `[1;33m[Kbat[m[K` | 6.9 ± 0.6 | 5.6 | 9.2 | 1.00 |

1913+[35m[Ktests/benchmarks/benchmark-results/syntax-highlighting-speed-miniz.c.json[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K "command": "[1;33m[Kbat[m[K … miniz.c",

1914+[35m[Ktests/benchmarks/benchmark-results/plain-text-speed.md[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K| `[1;33m[Kbat[m[K … --language=txt test_multiarray.py` | 10.4 ± 0.6 | 9.0 | 12.1 | 1.00 |

1915+[35m[Ktests/benchmarks/benchmark-results/syntax-highlighting-speed-jquery-3.3.1.js.json[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K "command": "/home/shark/.cargo-target/release/[1;33m[Kbat[m[K --style=full --color=always --paging=never test-src/jquery-3.3.1.js",

1916+[35m[Ktests/benchmarks/benchmark-results/syntax-highlighting-speed-test_multiarray.highlighted.txt.json[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K "command": "[1;33m[Kbat[m[K … test_multiarray.highlighted.txt",

1917+[35m[Ktests/benchmarks/benchmark-results/syntax-highlighting-speed-test_multiarray.ansi-sequences.txt.json[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K "command": "[1;33m[Kbat[m[K … test_multiarray.ansi-sequences.txt",

1918+[35m[Ktests/benchmarks/benchmark-results/syntax-highlighting-speed-jquery-3.3.1.min.js.json[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K "command": "/home/shark/.cargo-target/release/[1;33m[Kbat[m[K --style=full --color=always --paging=never test-src/jquery-3.3.1.min.js",

1919+[35m[Ktests/benchmarks/benchmark-results/ansi-sequence-forwarding.json[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K "command": "[1;33m[Kbat[m[K … test_multiarray.highlighted.txt",

1920+[35m[Ktests/benchmarks/benchmark-results/startup-time.json[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K "command": "[1;33m[Kbat[m[K",

1921+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K33[m[K[36m[K:[m[Kunset [1;33m[KBAT[m[K_CACHE_PATH

1922+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K34[m[K[36m[K:[m[Kunset [1;33m[KBAT[m[K_CONFIG_DIR

1923+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K35[m[K[36m[K:[m[Kunset [1;33m[KBAT[m[K_CONFIG_PATH

1924+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K36[m[K[36m[K:[m[Kunset [1;33m[KBAT[m[K_OPTS

1925+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K37[m[K[36m[K:[m[Kunset [1;33m[KBAT[m[K_PAGER

1926+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K38[m[K[36m[K:[m[Kunset [1;33m[KBAT[m[K_STYLE

1927+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K39[m[K[36m[K:[m[Kunset [1;33m[KBAT[m[K_TABS

1928+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K40[m[K[36m[K:[m[Kunset [1;33m[KBAT[m[K_THEME

1929+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K50[m[K[36m[K:[m[KTARGET_RELEASE="${TARGET_DIR}/release/[1;33m[Kbat[m[K"

1930+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K55[m[K[36m[K:[m[K[1;33m[KBAT[m[K=''

1931+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K58[m[K[36m[K:[m[K --system) [1;33m[KBAT[m[K="[1;33m[Kbat[m[K" ;;

1932+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K59[m[K[36m[K:[m[K --release) [1;33m[KBAT[m[K="$TARGET_RELEASE" ;;

1933+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K60[m[K[36m[K:[m[K --[1;33m[Kbat[m[K=*) [1;33m[KBAT[m[K="${arg:6}" ;;

1934+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K64[m[K[36m[K:[m[Kif [[ -z "$[1;33m[KBAT[m[K" ]]; then

1935+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K65[m[K[36m[K:[m[K echo "A build of '[1;33m[Kbat[m[K' must be specified for benchmarking."

1936+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K66[m[K[36m[K:[m[K echo "You can use '--system', '--release' or '--[1;33m[Kbat[m[K=path/to/[1;33m[Kbat[m[K'."

1937+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K70[m[K[36m[K:[m[Kif ! command -v "$[1;33m[KBAT[m[K" &>/dev/null; then

1938+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K71[m[K[36m[K:[m[K echo "Could not find the build of [1;33m[Kbat[m[K to benchmark ($[1;33m[KBAT[m[K)."

1939+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K72[m[K[36m[K:[m[K case "$[1;33m[KBAT[m[K" in

1940+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K73[m[K[36m[K:[m[K "[1;33m[Kbat[m[K") echo "Make you sure to symlink '[1;33m[Kbat[m[Kcat' as '[1;33m[Kbat[m[K'." ;;

1941+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K83[m[K[36m[K:[m[Kecho "## \`[1;33m[Kbat[m[K\` benchmark results" >> "$REPORT"

1942+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K88[m[K[36m[K:[m[K "$(printf "%q" "$[1;33m[KBAT[m[K") --no-config" \

1943+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K89[m[K[36m[K:[m[K --command-name "[1;33m[Kbat[m[K" \

1944+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K98[m[K[36m[K:[m[K "$(printf "%q" "$[1;33m[KBAT[m[K") --no-config --language=txt --style=plain test-src/test_multiarray.py" \

1945+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K99[m[K[36m[K:[m[K --command-name '[1;33m[Kbat[m[K … --language=txt test_multiarray.py' \

1946+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K111[m[K[36m[K:[m[K "$(printf "%q" "$[1;33m[KBAT[m[K") --no-config --style=full --color=always '$SRC'" \

1947+[35m[Ktests/benchmarks/run-benchmarks.sh[m[K[36m[K:[m[K[32m[K112[m[K[36m[K:[m[K --command-name "[1;33m[Kbat[m[K … ${filename}" \

1948+[35m[Ktests/snapshots/generate_snapshots.py[m[K[36m[K:[m[K[32m[K35[m[K[36m[K:[m[Kdef build_[1;33m[Kbat[m[K():

1949+[35m[Ktests/snapshots/generate_snapshots.py[m[K[36m[K:[m[K[32m[K36[m[K[36m[K:[m[K print("building [1;33m[Kbat[m[K")

1950+[35m[Ktests/snapshots/generate_snapshots.py[m[K[36m[K:[m[K[32m[K55[m[K[36m[K:[m[Kbuild_[1;33m[Kbat[m[K()

1951+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K11[m[K[36m[K:[m[K[1;33m[KBAT[m[K_OPTIONS = [

1952+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K23[m[K[36m[K:[m[K "[1;33m[Kbat[m[K_options",

1953+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K28[m[K[36m[K:[m[K options = [1;33m[KBAT[m[K_OPTIONS.copy()

1954+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K31[m[K[36m[K:[m[K options_file = path.join(source_dirpath, "[1;33m[Kbat[m[K_options")

1955+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K44[m[K[36m[K:[m[K env.pop("[1;33m[KBAT[m[K_CACHE_PATH", None)

1956+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K45[m[K[36m[K:[m[K env.pop("[1;33m[KBAT[m[K_CONFIG_DIR", None)

1957+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K46[m[K[36m[K:[m[K env.pop("[1;33m[KBAT[m[K_CONFIG_PATH", None)

1958+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K47[m[K[36m[K:[m[K env.pop("[1;33m[KBAT[m[K_OPTS", None)

1959+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K48[m[K[36m[K:[m[K env.pop("[1;33m[KBAT[m[K_PAGER", None)

1960+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K49[m[K[36m[K:[m[K env.pop("[1;33m[KBAT[m[K_STYLE", None)

1961+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K50[m[K[36m[K:[m[K env.pop("[1;33m[KBAT[m[K_TABS", None)

1962+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K51[m[K[36m[K:[m[K env.pop("[1;33m[KBAT[m[K_THEME", None)

1963+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K62[m[K[36m[K:[m[K [1;33m[Kbat[m[K_output = subprocess.check_output(

1964+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K63[m[K[36m[K:[m[K ["[1;33m[Kbat[m[K"] + get_options(source) + [source],

1965+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K74[m[K[36m[K:[m[K output_file.write([1;33m[Kbat[m[K_output)

1966+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K98[m[K[36m[K:[m[K "=== [1;33m[Kbat[m[K stdout:\n{}".format(err.stdout.decode("utf-8")),

1967+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K102[m[K[36m[K:[m[K "=== [1;33m[Kbat[m[K stderr:\n{}".format(err.stderr.decode("utf-8")),

1968+[35m[Ktests/syntax-tests/create_highlighted_versions.py[m[K[36m[K:[m[K[32m[K108[m[K[36m[K:[m[K "Error: Could not execute '[1;33m[Kbat[m[K'. Please make sure that the executable "

1969+[35m[Ktests/syntax-tests/BatTestCustomAssets.sublime-syntax[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[Kname: [1;33m[KBat[m[KTestCustomAssets

1970+[35m[Ktests/syntax-tests/BatTestCustomAssets.sublime-syntax[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K - [1;33m[Kbat[m[Ktestcustomassets

1971+[35m[Ktests/syntax-tests/BatTestCustomAssets.sublime-syntax[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[Kscope: source.[1;33m[Kbat[m[Ktestcustomassets

1972+[35m[Ktests/syntax-tests/BatTestCustomAssets.sublime-syntax[m[K[36m[K:[m[K[32m[K9[m[K[36m[K:[m[K# This syntax is used to test if custom assets work with [1;33m[Kbat[m[K.

1973+[35m[Ktests/syntax-tests/BatTestCustomAssets.sublime-syntax[m[K[36m[K:[m[K[32m[K20[m[K[36m[K:[m[K 1: keyword.other.[1;33m[Kbat[m[Ktestcustomassets-key

1974+[35m[Ktests/syntax-tests/BatTestCustomAssets.sublime-syntax[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[K 2: string.other.[1;33m[Kbat[m[Ktestcustomassets-value

1975+[35m[Ktests/syntax-tests/highlighted/C/test.c[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[K[38;2;248;248;242m [0m[38;2;117;113;94m/*[0m[38;2;117;113;94m This C program was written to help [1;33m[Kbat[m[K[0m

1976+[35m[Ktests/syntax-tests/highlighted/QML/BatSyntaxTest.qml[m[K[36m[K:[m[K[32m[K19[m[K[36m[K:[m[K[38;2;248;248;242m [0m[38;2;230;219;116mservice[0m[38;2;190;132;255m:[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116morg.[1;33m[Kbat[m[K.service[0m[38;2;230;219;116m"[0m

1977+[35m[Ktests/syntax-tests/highlighted/QML/BatSyntaxTest.qml[m[K[36m[K:[m[K[32m[K41[m[K[36m[K:[m[K[38;2;248;248;242m [0m[38;2;230;219;116mtext[0m[38;2;190;132;255m:[0m[38;2;248;248;242m [0m[38;2;248;248;242mqsTr[0m[38;2;255;255;255m([0m[38;2;230;219;116m"[0m[38;2;230;219;116mInstall [1;33m[KBat[m[K.[0m[38;2;230;219;116m"[0m[38;2;255;255;255m)[0m

1978+[35m[Ktests/syntax-tests/highlighted/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[K[38;2;248;248;242m ## `[1;33m[Kbat[m[K` as a library[0m

1979+[35m[Ktests/syntax-tests/highlighted/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K17[m[K[36m[K:[m[K[38;2;248;248;242mdiff --git a/src/bin/[1;33m[Kbat[m[K/app.rs b/src/bin/[1;33m[Kbat[m[K/app.rs[0m

1980+[35m[Ktests/syntax-tests/highlighted/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K19[m[K[36m[K:[m[K[38;2;117;113;94m---[0m[38;2;117;113;94m a/src/bin/[1;33m[Kbat[m[K/app.rs[0m

1981+[35m[Ktests/syntax-tests/highlighted/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K20[m[K[36m[K:[m[K[38;2;117;113;94m+++[0m[38;2;117;113;94m b/src/bin/[1;33m[Kbat[m[K/app.rs[0m

1982+[35m[Ktests/syntax-tests/highlighted/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K23[m[K[36m[K:[m[K[38;2;248;248;242m use [1;33m[Kbat[m[K::{[0m

1983+[35m[Ktests/syntax-tests/highlighted/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K61[m[K[36m[K:[m[K[38;2;248;248;242mdiff --git a/src/bin/[1;33m[Kbat[m[K/clap_app.rs b/src/bin/[1;33m[Kbat[m[K/clap_app.rs[0m

1984+[35m[Ktests/syntax-tests/highlighted/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K63[m[K[36m[K:[m[K[38;2;117;113;94m---[0m[38;2;117;113;94m a/src/bin/[1;33m[Kbat[m[K/clap_app.rs[0m

1985+[35m[Ktests/syntax-tests/highlighted/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K64[m[K[36m[K:[m[K[38;2;117;113;94m+++[0m[38;2;117;113;94m b/src/bin/[1;33m[Kbat[m[K/clap_app.rs[0m

1986+[35m[Ktests/syntax-tests/highlighted/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K66[m[K[36m[K:[m[K[38;2;248;248;242m data to [1;33m[Kbat[m[K from STDIN when [1;33m[Kbat[m[K does not otherwise know \[0m

1987+[35m[Ktests/syntax-tests/highlighted/Git Attributes/example.gitattributes[m[K[36m[K:[m[K[32m[K10[m[K[36m[K:[m[K[38;2;249;38;114m*[0m[38;2;166;226;46m.[0m[38;2;166;226;46m[1;33m[Kbat[m[K[0m[38;2;248;248;242m [0m[38;2;255;255;255mtext[0m[38;2;248;248;242m [0m[38;2;255;255;255meol[0m[38;2;248;248;242m=[0m[38;2;230;219;116mcrlf[0m

1988+[35m[Ktests/syntax-tests/highlighted/SSH Config/ssh_config[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[K[38;2;248;248;242m [0m[38;2;249;38;114m[1;33m[KBat[m[KchMode[0m[38;2;248;248;242m [0m[38;2;190;132;255mno[0m

1989+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K[38;2;190;132;255m[1;33m[KBAT[m[K[0m[38;2;249;38;114m([0m[38;2;230;219;116m1[0m[38;2;249;38;114m)[0m[38;2;248;248;242m [0m[38;2;253;151;31mGeneral[0m[38;2;253;151;31m [0m[38;2;253;151;31mCommands[0m[38;2;253;151;31m [0m[38;2;253;151;31mManual[0m[38;2;248;248;242m [0m[38;2;190;132;255m[1;33m[KBAT[m[K[0m[38;2;249;38;114m([0m[38;2;230;219;116m1[0m[38;2;249;38;114m)[0m

1990+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K[38;2;248;248;242m [1;33m[Kbat[m[K - a [0m[38;2;166;226;46mcat[0m[38;2;249;38;114m([0m[38;2;190;132;255m1[0m[38;2;249;38;114m)[0m[38;2;248;248;242m clone with syntax highlighting and Git integration.[0m

1991+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K[38;2;248;248;242m [1;33m[Kbat[m[K [0m[38;2;248;248;242m[[0m[38;2;248;248;242mOPTIONS[0m[38;2;248;248;242m][0m[38;2;248;248;242m [0m[38;2;248;248;242m[[0m[38;2;248;248;242mFILE[0m[38;2;248;248;242m][0m[38;2;248;248;242m...[0m

1992+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K9[m[K[36m[K:[m[K[38;2;248;248;242m [1;33m[Kbat[m[K cache [0m[38;2;248;248;242m[[0m[38;2;248;248;242mCACHE-OPTIONS[0m[38;2;248;248;242m][0m[38;2;248;248;242m [0m[38;2;248;248;242m[[0m[38;2;166;226;46m--build[0m[38;2;249;38;114m|[0m[38;2;166;226;46m--clear[0m[38;2;248;248;242m][0m

1993+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K12[m[K[36m[K:[m[K[38;2;248;248;242m [1;33m[Kbat[m[K prints the syntax-highlighted content of a collection of FILEs to[0m

1994+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[K[38;2;248;248;242m [1;33m[Kbat[m[K supports a large number of programming and markup languages. It[0m

1995+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K18[m[K[36m[K:[m[K[38;2;248;248;242m git index. [1;33m[Kbat[m[K automatically pipes its output through a pager (by de‐[0m

1996+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[K[38;2;248;248;242m Whenever the output of [1;33m[Kbat[m[K goes to a non-interactive terminal, i.e.[0m

1997+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K22[m[K[36m[K:[m[K[38;2;248;248;242m when the output is piped into another process or into a file, [1;33m[Kbat[m[K will[0m

1998+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K112[m[K[36m[K:[m[K[38;2;248;248;242m if the output of [1;33m[Kbat[m[K is piped to another program, but you want[0m

1999+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K119[m[K[36m[K:[m[K[38;2;248;248;242m set [1;33m[KBAT[m[K_PAGER to an empty string. To control which pager is[0m

2000+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K126[m[K[36m[K:[m[K[38;2;248;248;242m PAGER and [1;33m[KBAT[m[K_PAGER environment variables. The default pager is[0m

2001+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K143[m[K[36m[K:[m[K[38;2;248;248;242m [1;33m[KBAT[m[K_THEME environment variable (e.g.: export [1;33m[KBAT[m[K_THEME="...").[0m

2002+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K156[m[K[36m[K:[m[K[38;2;248;248;242m to the configuration file or export the [1;33m[KBAT[m[K_STYLE environment[0m

2003+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K157[m[K[36m[K:[m[K[38;2;248;248;242m variable (e.g.: export [1;33m[KBAT[m[K_STYLE=".."). Possible values: *auto*,[0m

2004+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K202[m[K[36m[K:[m[K[38;2;248;248;242m [1;33m[Kbat[m[K can also be customized with a configuration file. The location of[0m

2005+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K206[m[K[36m[K:[m[K[38;2;248;248;242m [1;33m[Kbat[m[K [0m[38;2;166;226;46m--config-file[0m

2006+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K208[m[K[36m[K:[m[K[38;2;248;248;242m Alternatively, you can use the [1;33m[KBAT[m[K_CONFIG_PATH environment variable to[0m

2007+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K209[m[K[36m[K:[m[K[38;2;248;248;242m point [1;33m[Kbat[m[K to a non-default location of the configuration file.[0m

2008+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K212[m[K[36m[K:[m[K[38;2;248;248;242m [1;33m[Kbat[m[K supports Sublime Text .sublime-syntax language files, and can be[0m

2009+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K214[m[K[36m[K:[m[K[38;2;248;248;242m do this, add the .sublime-snytax language files to `$([1;33m[Kbat[m[K [0m[38;2;166;226;46m--config-[0m

2010+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K215[m[K[36m[K:[m[K[38;2;248;248;242m dir)/syntaxes` and run `[1;33m[Kbat[m[K cache [0m[38;2;166;226;46m--build[0m[38;2;248;248;242m`.[0m

2011+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K219[m[K[36m[K:[m[K[38;2;248;248;242m mkdir [0m[38;2;166;226;46m-p[0m[38;2;248;248;242m "$([1;33m[Kbat[m[K [0m[38;2;166;226;46m--config-dir[0m[38;2;248;248;242m)/syntaxes"[0m

2012+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K220[m[K[36m[K:[m[K[38;2;248;248;242m cd "$([1;33m[Kbat[m[K [0m[38;2;166;226;46m--config-dir[0m[38;2;248;248;242m)/syntaxes"[0m

2013+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K227[m[K[36m[K:[m[K[38;2;248;248;242m [1;33m[Kbat[m[K cache [0m[38;2;166;226;46m--build[0m

2014+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K229[m[K[36m[K:[m[K[38;2;248;248;242m Once the cache is built, the new language will be visible in `[1;33m[Kbat[m[K[0m

2015+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K232[m[K[36m[K:[m[K[38;2;248;248;242m cache with `[1;33m[Kbat[m[K cache [0m[38;2;166;226;46m--clear[0m[38;2;248;248;242m`.[0m

2016+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K235[m[K[36m[K:[m[K[38;2;248;248;242m Similarly to custom languages, [1;33m[Kbat[m[K supports Sublime Text .tmTheme[0m

2017+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K236[m[K[36m[K:[m[K[38;2;248;248;242m themes. These can be installed to `$([1;33m[Kbat[m[K [0m[38;2;166;226;46m--config-dir[0m[38;2;248;248;242m)/themes`, and[0m

2018+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K237[m[K[36m[K:[m[K[38;2;248;248;242m are added to the cache with `[1;33m[Kbat[m[K cache [0m[38;2;166;226;46m--build[0m[38;2;248;248;242m`.[0m

2019+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K240[m[K[36m[K:[m[K[38;2;248;248;242m For more information and up-to-date documentation, visit the [1;33m[Kbat[m[K repo:[0m

2020+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K241[m[K[36m[K:[m[K[38;2;248;248;242m https://github.com/sharkdp/[1;33m[Kbat[m[K[0m

2021+[35m[Ktests/syntax-tests/highlighted/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K243[m[K[36m[K:[m[K[38;2;248;248;242m [0m[38;2;166;226;46m[1;33m[KBAT[m[K[0m[38;2;249;38;114m([0m[38;2;190;132;255m1[0m[38;2;249;38;114m)[0m

2022+[35m[Ktests/syntax-tests/highlighted/Svelte/App.svelte[m[K[36m[K:[m[K[32m[K30[m[K[36m[K:[m[K[38;2;248;248;242m [0m[38;2;246;170;17m// This block is a regression test for a [1;33m[Kbat[m[K panic when a LiveScript syntax definition is missing[0m

2023+[35m[Ktests/syntax-tests/highlighted/VimL/source.vim[m[K[36m[K:[m[K[32m[K77[m[K[36m[K:[m[K[38;2;117;113;94m" Error case from issue #1604 (https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/1064)[0m

2024+[35m[Ktests/syntax-tests/highlighted/Java/test.java[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K[38;2;117;113;94m/*[0m[38;2;117;113;94m This Java program was submiited to help [1;33m[Kbat[m[K[0m

2025+[35m[Ktests/syntax-tests/highlighted/Sass/example.sass[m[K[36m[K:[m[K[32m[K46[m[K[36m[K:[m[K[38;2;248;248;242m [0m[3;38;2;102;217;239mbackground-image[0m[38;2;255;255;255m:[0m[38;2;248;248;242m [0m[38;2;102;217;239murl[0m[38;2;255;255;255m([0m[38;2;230;219;116m"[0m[38;2;230;219;116mhttps://github.com/sharkdp/[1;33m[Kbat[m[K/raw/master/doc/logo-header.svg[0m[38;2;230;219;116m"[0m[38;2;255;255;255m)[0m

2026+[35m[Ktests/syntax-tests/highlighted/HTML/test.html[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K[38;2;248;248;242m [0m[38;2;255;255;255m<[0m[38;2;249;38;114mtitle[0m[38;2;255;255;255m>[0m[38;2;248;248;242m[1;33m[KBat[m[K Syntax Test[0m[38;2;255;255;255m</[0m[38;2;249;38;114mtitle[0m[38;2;255;255;255m>[0m

2027+[35m[Ktests/syntax-tests/highlighted/Cpp/test.cpp[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K[38;2;117;113;94m/*[0m[38;2;117;113;94m This C program was submitted to help [1;33m[Kbat[m[K[0m

2028+[35m[Ktests/syntax-tests/highlighted/Crystal/test.cr[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K[38;2;117;113;94m#[0m[38;2;117;113;94m An example file to test Crystal syntax highlighting in [1;33m[Kbat[m[K[0m

2029+[35m[Ktests/syntax-tests/highlighted/Crystal/test.cr[m[K[36m[K:[m[K[32m[K58[m[K[36m[K:[m[K[38;2;248;248;242mgreeter [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[3;38;2;166;226;46mGreeter[0m[38;2;248;248;242m.[0m[38;2;249;38;114mnew[0m[38;2;248;248;242m([0m[38;2;230;219;116m"[0m[38;2;230;219;116m[1;33m[Kbat[m[K[0m[38;2;230;219;116m"[0m[38;2;248;248;242m)[0m

2030+[35m[Ktests/syntax-tests/highlighted/GLSL/test.glsl[m[K[36m[K:[m[K[32m[K38[m[K[36m[K:[m[K[38;2;248;248;242m [0m[38;2;117;113;94m//[0m[38;2;117;113;94m This GLSL code serves the purpose of [1;33m[Kbat[m[K syntax highlighting tests[0m

2031+[35m[Ktests/syntax-tests/highlighted/CMake/CMakeLists.txt[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K[38;2;102;217;239mproject[0m[38;2;248;248;242m([0m[38;2;248;248;242mhello-[1;33m[Kbat[m[K[0m[38;2;248;248;242m [0m[3;38;2;253;151;31mVERSION[0m[38;2;248;248;242m [0m[38;2;248;248;242m0.0.1[0m[38;2;248;248;242m [0m[3;38;2;253;151;31mLANGUAGES[0m[38;2;248;248;242m [0m[38;2;248;248;242mC[0m[38;2;248;248;242m)[0m

2032+[35m[Ktests/syntax-tests/highlighted/CMake/CMakeLists.txt[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[K[38;2;102;217;239madd_executable[0m[38;2;248;248;242m([0m[38;2;248;248;242mhello-[1;33m[Kbat[m[K[0m[38;2;248;248;242m [0m[38;2;248;248;242mSOURCES[0m[38;2;248;248;242m)[0m

2033+[35m[Ktests/syntax-tests/highlighted/CMake/CMakeLists.txt[m[K[36m[K:[m[K[32m[K11[m[K[36m[K:[m[K[38;2;102;217;239mtarget_link_libraries[0m[38;2;248;248;242m([0m[38;2;248;248;242mhello-[1;33m[Kbat[m[K[0m[38;2;248;248;242m [0m[38;2;248;248;242massimp[0m[38;2;248;248;242m)[0m

2034+[35m[Ktests/syntax-tests/highlighted/SCSS/example.scss[m[K[36m[K:[m[K[32m[K48[m[K[36m[K:[m[K[38;2;248;248;242m [0m[3;38;2;102;217;239mbackground-image[0m[38;2;255;255;255m:[0m[38;2;248;248;242m [0m[38;2;102;217;239murl[0m[38;2;255;255;255m([0m[38;2;230;219;116m"[0m[38;2;230;219;116mhttps://github.com/sharkdp/[1;33m[Kbat[m[K/raw/master/doc/logo-header.svg[0m[38;2;230;219;116m"[0m[38;2;255;255;255m)[0m[38;2;255;255;255m;[0m

2035+[35m[Ktests/syntax-tests/highlighted/TOML/Cargo.toml[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K[38;2;249;38;114mhomepage[0m[38;2;248;248;242m [0m[38;2;248;248;242m=[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mhttps://github.com/sharkdp/[1;33m[Kbat[m[K[0m[38;2;230;219;116m"[0m

2036+[35m[Ktests/syntax-tests/highlighted/TOML/Cargo.toml[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K[38;2;249;38;114mname[0m[38;2;248;248;242m [0m[38;2;248;248;242m=[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116m[1;33m[Kbat[m[K[0m[38;2;230;219;116m"[0m

2037+[35m[Ktests/syntax-tests/highlighted/TOML/Cargo.toml[m[K[36m[K:[m[K[32m[K9[m[K[36m[K:[m[K[38;2;249;38;114mrepository[0m[38;2;248;248;242m [0m[38;2;248;248;242m=[0m[38;2;248;248;242m [0m[38;2;230;219;116m"[0m[38;2;230;219;116mhttps://github.com/sharkdp/[1;33m[Kbat[m[K[0m[38;2;230;219;116m"[0m

2038+[35m[Ktests/syntax-tests/highlighted/TOML/Cargo.toml[m[K[36m[K:[m[K[32m[K20[m[K[36m[K:[m[K[38;2;117;113;94m#[0m[38;2;117;113;94m Feature required for [1;33m[Kbat[m[K the application. Should be disabled when depending on[0m

2039+[35m[Ktests/syntax-tests/highlighted/TOML/Cargo.toml[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[K[38;2;117;113;94m#[0m[38;2;117;113;94m [1;33m[Kbat[m[K as a library.[0m

2040+[35m[Ktests/syntax-tests/highlighted/Erlang/bat_erlang.erl[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K[38;2;190;132;255m-[0m[38;2;249;38;114mmodule[0m[38;2;190;132;255m([0m[38;2;166;226;46m[1;33m[Kbat[m[K_erlang[0m[38;2;190;132;255m)[0m[38;2;190;132;255m.[0m

2041+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K[3;38;2;124;120;101m#[0m[3;38;2;124;120;101m [1;33m[Kbat[m[K-extras | Copyright (C) 2020 eth-p and contributors | MIT License[0m

2042+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K[3;38;2;124;120;101m#[0m[3;38;2;124;120;101m Repository: https://github.com/eth-p/[1;33m[Kbat[m[K-extras[0m

2043+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K[3;38;2;124;120;101m#[0m[3;38;2;124;120;101m Issues: https://github.com/eth-p/[1;33m[Kbat[m[K-extras/issues[0m

2044+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K37[m[K[36m[K:[m[K[38;2;255;255;255mprintc[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m%{YELLOW}[%s warning]%{CLEAR}: [0m[38;2;255;255;255m$[0m[38;2;255;255;255m1[0m[38;2;230;219;116m%{CLEAR}\n[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m[1;33m[Kbat[m[Kgrep[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;255;255;255m$[0m[38;2;230;219;116m{[0m[38;2;255;255;255m@[0m[38;2;249;38;114m:[0m[38;2;190;132;255m2[0m[38;2;230;219;116m}[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;190;132;255m1[0m[38;2;249;38;114m>&[0m[38;2;190;132;255m2[0m

2045+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K40[m[K[36m[K:[m[K[38;2;255;255;255mprintc[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m%{RED}[%s error]%{CLEAR}: [0m[38;2;255;255;255m$[0m[38;2;255;255;255m1[0m[38;2;230;219;116m%{CLEAR}\n[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m[1;33m[Kbat[m[Kgrep[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;255;255;255m$[0m[38;2;230;219;116m{[0m[38;2;255;255;255m@[0m[38;2;249;38;114m:[0m[38;2;190;132;255m2[0m[38;2;230;219;116m}[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;190;132;255m1[0m[38;2;249;38;114m>&[0m[38;2;190;132;255m2[0m

2046+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K116[m[K[36m[K:[m[K[38;2;249;38;114mif[0m[38;2;255;255;255m [0m[38;2;102;217;239m[[[0m[38;2;255;255;255m [0m[3;38;2;253;151;31m-[0m[3;38;2;253;151;31mn[0m[38;2;255;255;255m [0m[38;2;255;255;255m$[0m[38;2;255;255;255m{[0m[38;2;255;255;255m[1;33m[KBAT[m[K_PAGER[0m[38;2;249;38;114m+[0m[38;2;255;255;255mx[0m[38;2;255;255;255m}[0m[38;2;255;255;255m [0m[38;2;102;217;239m]][0m[38;2;249;38;114m;[0m[38;2;249;38;114mthen[0m

2047+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K117[m[K[36m[K:[m[K[38;2;255;255;255mSCRIPT_PAGER_CMD[0m[38;2;249;38;114m=[0m[38;2;255;255;255m([0m[38;2;255;255;255m$[0m[38;2;255;255;255m[1;33m[KBAT[m[K_PAGER[0m[38;2;255;255;255m)[0m

2048+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K169[m[K[36m[K:[m[K[38;2;255;255;255mprintc[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m%{RED}%s: '%s' requires a value%{CLEAR}\n[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m[1;33m[Kbat[m[Kgrep[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;255;255;255m$[0m[38;2;255;255;255mARG[0m[38;2;255;255;255m"[0m

2049+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K185[m[K[36m[K:[m[K[38;2;249;38;114m*[0m[38;2;249;38;114m)[0m[38;2;255;255;255mprintc[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m%{RED}%s: '--color' expects value of 'auto', 'always', or 'never'%{CLEAR}\n[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m[1;33m[Kbat[m[Kgrep[0m[38;2;255;255;255m"[0m

2050+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K217[m[K[36m[K:[m[K[38;2;249;38;114m*[0m[38;2;249;38;114m)[0m[38;2;255;255;255mprintc[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m%{RED}%s: '--paging' expects value of 'auto', 'always', or 'never'%{CLEAR}\n[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m[1;33m[Kbat[m[Kgrep[0m[38;2;255;255;255m"[0m

2051+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K238[m[K[36m[K:[m[K[38;2;255;255;255m"[0m[38;2;230;219;116m[1;33m[Kbat[m[Kgrep[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m\[0m

2052+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K241[m[K[36m[K:[m[K[38;2;255;255;255m"[0m[38;2;230;219;116mhttps://github.com/eth-p/[1;33m[Kbat[m[K-extras[0m[38;2;255;255;255m"[0m

2053+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K269[m[K[36m[K:[m[K[38;2;166;226;46m[1;33m[Kbat[m[K_version[0m[38;2;255;255;255m([0m[38;2;255;255;255m)[0m[38;2;255;255;255m{[0m

2054+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K270[m[K[36m[K:[m[K[38;2;255;255;255m"[0m[38;2;230;219;116m[1;33m[Kbat[m[K[0m[38;2;255;255;255m"[0m[3;38;2;253;151;31m --[0m[3;38;2;253;151;31mversion[0m[38;2;249;38;114m|[0m[38;2;255;255;255mcut[0m[3;38;2;253;151;31m -[0m[3;38;2;253;151;31md[0m[38;2;255;255;255m [0m[38;2;255;255;255m'[0m[38;2;230;219;116m [0m[38;2;255;255;255m'[0m[3;38;2;253;151;31m -[0m[3;38;2;253;151;31mf[0m[38;2;255;255;255m 2[0m

2055+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K319[m[K[36m[K:[m[K[38;2;255;255;255m[1;33m[KBAT[m[K_ARGS[0m[38;2;249;38;114m=[0m[38;2;255;255;255m([0m[38;2;255;255;255m)[0m

2056+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K330[m[K[36m[K:[m[K[38;2;255;255;255m[1;33m[KBAT[m[K_STYLE[0m[38;2;249;38;114m=[0m[38;2;255;255;255m"[0m[38;2;230;219;116mheader,numbers[0m[38;2;255;255;255m"[0m

2057+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K331[m[K[36m[K:[m[K[38;2;249;38;114mif[0m[38;2;255;255;255m [0m[38;2;255;255;255mversion_compare[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;255;255;255m$[0m[38;2;230;219;116m([0m[38;2;255;255;255m[1;33m[Kbat[m[K_version[0m[38;2;230;219;116m)[0m[38;2;255;255;255m"[0m[3;38;2;253;151;31m -[0m[3;38;2;253;151;31mgt[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m0.12[0m[38;2;255;255;255m"[0m[38;2;249;38;114m;[0m[38;2;249;38;114mthen[0m

2058+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K419[m[K[36m[K:[m[K[38;2;255;255;255mprintc[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m%{RED}%s: unknown option '%s'%{CLEAR}\n[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;230;219;116m[1;33m[Kbat[m[Kgrep[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;255;255;255m$[0m[38;2;255;255;255mOPT[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;190;132;255m1[0m[38;2;249;38;114m>&[0m[38;2;190;132;255m2[0m

2059+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K444[m[K[36m[K:[m[K[38;2;255;255;255m[1;33m[KBAT[m[K_ARGS[0m[38;2;249;38;114m+=[0m[38;2;255;255;255m([0m[38;2;255;255;255m"[0m[38;2;230;219;116m--color=always[0m[38;2;255;255;255m"[0m[38;2;255;255;255m)[0m

2060+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K446[m[K[36m[K:[m[K[38;2;255;255;255m[1;33m[KBAT[m[K_ARGS[0m[38;2;249;38;114m+=[0m[38;2;255;255;255m([0m[38;2;255;255;255m"[0m[38;2;230;219;116m--color=never[0m[38;2;255;255;255m"[0m[38;2;255;255;255m)[0m

2061+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K462[m[K[36m[K:[m[K[38;2;255;255;255m'[0m[38;2;230;219;116mthe pager was explicitly disabled by $[1;33m[KBAT[m[K_PAGER or the[0m[38;2;255;255;255m'[0m[38;2;255;255;255m [0m[38;2;255;255;255m\[0m

2062+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K482[m[K[36m[K:[m[K[38;2;255;255;255m"[0m[38;2;230;219;116m[1;33m[Kbat[m[K[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m"[0m[38;2;255;255;255m$[0m[38;2;230;219;116m{[0m[38;2;255;255;255m[1;33m[KBAT[m[K_ARGS[0m[38;2;255;255;255m[[0m[38;2;255;255;255m@[0m[38;2;255;255;255m][0m[38;2;230;219;116m}[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m\[0m

2063+[35m[Ktests/syntax-tests/highlighted/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K485[m[K[36m[K:[m[K[3;38;2;253;151;31m--[0m[3;38;2;253;151;31mstyle[0m[38;2;249;38;114m=[0m[38;2;255;255;255m"[0m[38;2;255;255;255m$[0m[38;2;255;255;255m[1;33m[KBAT[m[K_STYLE[0m[38;2;255;255;255m$[0m[38;2;255;255;255mOPT_SNIP[0m[38;2;255;255;255m"[0m[38;2;255;255;255m [0m[38;2;255;255;255m\[0m

2064+[35m[Ktests/syntax-tests/highlighted/Bash/simple.sh[m[K[36m[K:[m[K[32m[K15[m[K[36m[K:[m[K[38;2;255;255;255m [0m[38;2;249;38;114m|[0m[38;2;255;255;255m [0m[38;2;255;255;255mcat[0m[38;2;255;255;255m [0m[38;2;249;38;114m|[0m[38;2;255;255;255m [0m[38;2;255;255;255m[1;33m[Kbat[m[K[0m[38;2;255;255;255m -[0m[38;2;255;255;255m [0m[38;2;249;38;114m|[0m[38;2;255;255;255m [0m[38;2;255;255;255mcat[0m

2065+[35m[Ktests/syntax-tests/highlighted/Bash/simple.sh[m[K[36m[K:[m[K[32m[K20[m[K[36m[K:[m[K[38;2;249;38;114mif[0m[38;2;255;255;255m [0m[38;2;102;217;239mcommand[0m[38;2;255;255;255m [0m[3;38;2;253;151;31m-[0m[3;38;2;253;151;31mv[0m[38;2;255;255;255m [1;33m[Kbat[m[K [0m[38;2;249;38;114m&>[0m[38;2;255;255;255m /dev/null[0m[38;2;249;38;114m;[0m[38;2;255;255;255m [0m[38;2;249;38;114mthen[0m

2066+[35m[Ktests/syntax-tests/highlighted/Rust/output.rs[m[K[36m[K:[m[K[32m[K39[m[K[36m[K:[m[K[38;2;248;248;242m [0m[3;38;2;102;217;239mlet[0m[38;2;248;248;242m pager_from_env [0m[38;2;249;38;114m=[0m[38;2;248;248;242m [0m[38;2;249;38;114mmatch[0m[38;2;248;248;242m [0m[38;2;248;248;242m([0m[38;2;248;248;242menv[0m[38;2;248;248;242m::[0m[38;2;248;248;242mvar[0m[38;2;248;248;242m([0m[38;2;230;219;116m"[0m[38;2;230;219;116m[1;33m[KBAT[m[K_PAGER[0m[38;2;230;219;116m"[0m[38;2;248;248;242m)[0m[38;2;248;248;242m,[0m[38;2;248;248;242m [0m[38;2;248;248;242menv[0m[38;2;248;248;242m::[0m[38;2;248;248;242mvar[0m[38;2;248;248;242m([0m[38;2;230;219;116m"[0m[38;2;230;219;116mPAGER[0m[38;2;230;219;116m"[0m[38;2;248;248;242m)[0m[38;2;248;248;242m)[0m[38;2;248;248;242m [0m[38;2;248;248;242m{[0m

2067+[35m[Ktests/syntax-tests/highlighted/Rust/output.rs[m[K[36m[K:[m[K[32m[K40[m[K[36m[K:[m[K[38;2;248;248;242m [0m[38;2;248;248;242m([0m[3;38;2;166;226;46mOk[0m[38;2;248;248;242m([0m[38;2;248;248;242m[1;33m[Kbat[m[K_pager[0m[38;2;248;248;242m)[0m[38;2;248;248;242m,[0m[38;2;248;248;242m [0m[38;2;249;38;114m_[0m[38;2;248;248;242m)[0m[38;2;248;248;242m [0m[38;2;249;38;114m=>[0m[38;2;248;248;242m [0m[3;38;2;166;226;46mSome[0m[38;2;248;248;242m([0m[38;2;248;248;242m[1;33m[Kbat[m[K_pager[0m[38;2;248;248;242m)[0m[38;2;248;248;242m,[0m

2068+[35m[Ktests/syntax-tests/highlighted/Rust/output.rs[m[K[36m[K:[m[K[32m[K43[m[K[36m[K:[m[K[38;2;248;248;242m [0m[38;2;117;113;94m//[0m[38;2;117;113;94m ANSI color sequences printed by [1;33m[Kbat[m[K. If someone has set PAGER="less -F", we[0m

2069+[35m[Ktests/syntax-tests/highlighted/Rust/output.rs[m[K[36m[K:[m[K[32m[K46[m[K[36m[K:[m[K[38;2;248;248;242m [0m[38;2;117;113;94m//[0m[38;2;117;113;94m We only do this for PAGER (as it is not specific to '[1;33m[Kbat[m[K'), not for [1;33m[KBAT[m[K_PAGER[0m

2070+[35m[Ktests/syntax-tests/highlighted/Rust/output.rs[m[K[36m[K:[m[K[32m[K47[m[K[36m[K:[m[K[38;2;248;248;242m [0m[38;2;117;113;94m//[0m[38;2;117;113;94m or [1;33m[Kbat[m[Ks '--pager' command line option.[0m

2071+[35m[Ktests/syntax-tests/highlighted/Rust/output.rs[m[K[36m[K:[m[K[32m[K71[m[K[36m[K:[m[K[38;2;248;248;242m [0m[38;2;249;38;114mif[0m[38;2;248;248;242m pager_path[0m[38;2;248;248;242m.[0m[38;2;102;217;239mfile_stem[0m[38;2;248;248;242m([0m[38;2;248;248;242m)[0m[38;2;248;248;242m [0m[38;2;249;38;114m==[0m[38;2;248;248;242m [0m[3;38;2;166;226;46mSome[0m[38;2;248;248;242m([0m[38;2;249;38;114m&[0m[38;2;248;248;242mOsString[0m[38;2;248;248;242m::[0m[38;2;248;248;242mfrom[0m[38;2;248;248;242m([0m[38;2;230;219;116m"[0m[38;2;230;219;116m[1;33m[Kbat[m[K[0m[38;2;230;219;116m"[0m[38;2;248;248;242m)[0m[38;2;248;248;242m)[0m[38;2;248;248;242m [0m[38;2;248;248;242m{[0m

2072+[35m[Ktests/syntax-tests/source/C/test.c[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[K /* This C program was written to help [1;33m[Kbat[m[K

2073+[35m[Ktests/syntax-tests/source/QML/BatSyntaxTest.qml[m[K[36m[K:[m[K[32m[K19[m[K[36m[K:[m[K service: "org.[1;33m[Kbat[m[K.service"

2074+[35m[Ktests/syntax-tests/source/QML/BatSyntaxTest.qml[m[K[36m[K:[m[K[32m[K41[m[K[36m[K:[m[K text: qsTr("Install [1;33m[KBat[m[K.")

2075+[35m[Ktests/syntax-tests/source/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[K ## `[1;33m[Kbat[m[K` as a library

2076+[35m[Ktests/syntax-tests/source/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K17[m[K[36m[K:[m[Kdiff --git a/src/bin/[1;33m[Kbat[m[K/app.rs b/src/bin/[1;33m[Kbat[m[K/app.rs

2077+[35m[Ktests/syntax-tests/source/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K19[m[K[36m[K:[m[K--- a/src/bin/[1;33m[Kbat[m[K/app.rs

2078+[35m[Ktests/syntax-tests/source/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K20[m[K[36m[K:[m[K+++ b/src/bin/[1;33m[Kbat[m[K/app.rs

2079+[35m[Ktests/syntax-tests/source/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K23[m[K[36m[K:[m[K use [1;33m[Kbat[m[K::{

2080+[35m[Ktests/syntax-tests/source/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K61[m[K[36m[K:[m[Kdiff --git a/src/bin/[1;33m[Kbat[m[K/clap_app.rs b/src/bin/[1;33m[Kbat[m[K/clap_app.rs

2081+[35m[Ktests/syntax-tests/source/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K63[m[K[36m[K:[m[K--- a/src/bin/[1;33m[Kbat[m[K/clap_app.rs

2082+[35m[Ktests/syntax-tests/source/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K64[m[K[36m[K:[m[K+++ b/src/bin/[1;33m[Kbat[m[K/clap_app.rs

2083+[35m[Ktests/syntax-tests/source/Diff/82e7786e747b1fcfac1f963ae6415a22ec9caae1.diff[m[K[36m[K:[m[K[32m[K66[m[K[36m[K:[m[K data to [1;33m[Kbat[m[K from STDIN when [1;33m[Kbat[m[K does not otherwise know \

2084+[35m[Ktests/syntax-tests/source/Git Attributes/example.gitattributes[m[K[36m[K:[m[K[32m[K10[m[K[36m[K:[m[K*.[1;33m[Kbat[m[K text eol=crlf

2085+[35m[Ktests/syntax-tests/source/SSH Config/ssh_config[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[K [1;33m[KBat[m[KchMode no

2086+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K[1;33m[KBAT[m[K(1) General Commands Manual [1;33m[KBAT[m[K(1)

2087+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K4[m[K[36m[K:[m[K [1;33m[Kbat[m[K - a cat(1) clone with syntax highlighting and Git integration.

2088+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[K [1;33m[Kbat[m[K [OPTIONS] [FILE]...

2089+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K9[m[K[36m[K:[m[K [1;33m[Kbat[m[K cache [CACHE-OPTIONS] [--build|--clear]

2090+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K12[m[K[36m[K:[m[K [1;33m[Kbat[m[K prints the syntax-highlighted content of a collection of FILEs to

2091+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K16[m[K[36m[K:[m[K [1;33m[Kbat[m[K supports a large number of programming and markup languages. It

2092+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K18[m[K[36m[K:[m[K git index. [1;33m[Kbat[m[K automatically pipes its output through a pager (by de‐

2093+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[K Whenever the output of [1;33m[Kbat[m[K goes to a non-interactive terminal, i.e.

2094+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K22[m[K[36m[K:[m[K when the output is piped into another process or into a file, [1;33m[Kbat[m[K will

2095+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K112[m[K[36m[K:[m[K if the output of [1;33m[Kbat[m[K is piped to another program, but you want

2096+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K119[m[K[36m[K:[m[K set [1;33m[KBAT[m[K_PAGER to an empty string. To control which pager is

2097+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K126[m[K[36m[K:[m[K PAGER and [1;33m[KBAT[m[K_PAGER environment variables. The default pager is

2098+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K143[m[K[36m[K:[m[K [1;33m[KBAT[m[K_THEME environment variable (e.g.: export [1;33m[KBAT[m[K_THEME="...").

2099+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K156[m[K[36m[K:[m[K to the configuration file or export the [1;33m[KBAT[m[K_STYLE environment

2100+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K157[m[K[36m[K:[m[K variable (e.g.: export [1;33m[KBAT[m[K_STYLE=".."). Possible values: *auto*,

2101+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K202[m[K[36m[K:[m[K [1;33m[Kbat[m[K can also be customized with a configuration file. The location of

2102+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K206[m[K[36m[K:[m[K [1;33m[Kbat[m[K --config-file

2103+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K208[m[K[36m[K:[m[K Alternatively, you can use the [1;33m[KBAT[m[K_CONFIG_PATH environment variable to

2104+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K209[m[K[36m[K:[m[K point [1;33m[Kbat[m[K to a non-default location of the configuration file.

2105+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K212[m[K[36m[K:[m[K [1;33m[Kbat[m[K supports Sublime Text .sublime-syntax language files, and can be

2106+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K214[m[K[36m[K:[m[K do this, add the .sublime-snytax language files to `$([1;33m[Kbat[m[K --config-

2107+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K215[m[K[36m[K:[m[K dir)/syntaxes` and run `[1;33m[Kbat[m[K cache --build`.

2108+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K219[m[K[36m[K:[m[K mkdir -p "$([1;33m[Kbat[m[K --config-dir)/syntaxes"

2109+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K220[m[K[36m[K:[m[K cd "$([1;33m[Kbat[m[K --config-dir)/syntaxes"

2110+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K227[m[K[36m[K:[m[K [1;33m[Kbat[m[K cache --build

2111+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K229[m[K[36m[K:[m[K Once the cache is built, the new language will be visible in `[1;33m[Kbat[m[K

2112+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K232[m[K[36m[K:[m[K cache with `[1;33m[Kbat[m[K cache --clear`.

2113+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K235[m[K[36m[K:[m[K Similarly to custom languages, [1;33m[Kbat[m[K supports Sublime Text .tmTheme

2114+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K236[m[K[36m[K:[m[K themes. These can be installed to `$([1;33m[Kbat[m[K --config-dir)/themes`, and

2115+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K237[m[K[36m[K:[m[K are added to the cache with `[1;33m[Kbat[m[K cache --build`.

2116+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K240[m[K[36m[K:[m[K For more information and up-to-date documentation, visit the [1;33m[Kbat[m[K repo:

2117+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K241[m[K[36m[K:[m[K https://github.com/sharkdp/[1;33m[Kbat[m[K

2118+[35m[Ktests/syntax-tests/source/Manpage/bat-0.16.man[m[K[36m[K:[m[K[32m[K243[m[K[36m[K:[m[K [1;33m[KBAT[m[K(1)

2119+[35m[Ktests/syntax-tests/source/Svelte/App.svelte[m[K[36m[K:[m[K[32m[K30[m[K[36m[K:[m[K // This block is a regression test for a [1;33m[Kbat[m[K panic when a LiveScript syntax definition is missing

2120+[35m[Ktests/syntax-tests/source/VimL/source.vim[m[K[36m[K:[m[K[32m[K77[m[K[36m[K:[m[K" Error case from issue #1604 (https://github.com/sharkdp/[1;33m[Kbat[m[K/issues/1064)

2121+[35m[Ktests/syntax-tests/source/Git Config/LICENSE.md[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[KThe `test.gitconfig` file has been added from https://github.com/sharkdp/[1;33m[Kbat[m[K/pull/1336#issuecomment-715905807. Its "free to use".

2122+[35m[Ktests/syntax-tests/source/Java/test.java[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K/* This Java program was submiited to help [1;33m[Kbat[m[K

2123+[35m[Ktests/syntax-tests/source/Sass/example.sass[m[K[36m[K:[m[K[32m[K46[m[K[36m[K:[m[K background-image: url("https://github.com/sharkdp/[1;33m[Kbat[m[K/raw/master/doc/logo-header.svg")

2124+[35m[Ktests/syntax-tests/source/HTML/test.html[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K <title>[1;33m[KBat[m[K Syntax Test</title>

2125+[35m[Ktests/syntax-tests/source/Cpp/test.cpp[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K/* This C program was submitted to help [1;33m[Kbat[m[K

2126+[35m[Ktests/syntax-tests/source/Crystal/test.cr[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K# An example file to test Crystal syntax highlighting in [1;33m[Kbat[m[K

2127+[35m[Ktests/syntax-tests/source/Crystal/test.cr[m[K[36m[K:[m[K[32m[K58[m[K[36m[K:[m[Kgreeter = Greeter.new("[1;33m[Kbat[m[K")

2128+[35m[Ktests/syntax-tests/source/GLSL/test.glsl[m[K[36m[K:[m[K[32m[K38[m[K[36m[K:[m[K // This GLSL code serves the purpose of [1;33m[Kbat[m[K syntax highlighting tests

2129+[35m[Ktests/syntax-tests/source/Java Server Page (JSP)/LICENSE.md[m[K[36m[K:[m[K[32m[K216[m[K[36m[K:[m[KFor the Eclipse JDT Core [1;33m[KBat[m[Kch Compiler (ecj-x.x.x.jar) component and the

2130+[35m[Ktests/syntax-tests/source/Java Server Page (JSP)/NOTICE[m[K[36m[K:[m[K[32m[K23[m[K[36m[K:[m[KJDT Core [1;33m[KBat[m[Kch Compiler component, which is open source software.

2131+[35m[Ktests/syntax-tests/source/CMake/CMakeLists.txt[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[Kproject(hello-[1;33m[Kbat[m[K VERSION 0.0.1 LANGUAGES C)

2132+[35m[Ktests/syntax-tests/source/CMake/CMakeLists.txt[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[Kadd_executable(hello-[1;33m[Kbat[m[K SOURCES)

2133+[35m[Ktests/syntax-tests/source/CMake/CMakeLists.txt[m[K[36m[K:[m[K[32m[K11[m[K[36m[K:[m[Ktarget_link_libraries(hello-[1;33m[Kbat[m[K assimp)

2134+[35m[Ktests/syntax-tests/source/SCSS/example.scss[m[K[36m[K:[m[K[32m[K48[m[K[36m[K:[m[K background-image: url("https://github.com/sharkdp/[1;33m[Kbat[m[K/raw/master/doc/logo-header.svg");

2135+[35m[Ktests/syntax-tests/source/TOML/Cargo.toml[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[Khomepage = "https://github.com/sharkdp/[1;33m[Kbat[m[K"

2136+[35m[Ktests/syntax-tests/source/TOML/Cargo.toml[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[Kname = "[1;33m[Kbat[m[K"

2137+[35m[Ktests/syntax-tests/source/TOML/Cargo.toml[m[K[36m[K:[m[K[32m[K9[m[K[36m[K:[m[Krepository = "https://github.com/sharkdp/[1;33m[Kbat[m[K"

2138+[35m[Ktests/syntax-tests/source/TOML/Cargo.toml[m[K[36m[K:[m[K[32m[K20[m[K[36m[K:[m[K# Feature required for [1;33m[Kbat[m[K the application. Should be disabled when depending on

2139+[35m[Ktests/syntax-tests/source/TOML/Cargo.toml[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[K# [1;33m[Kbat[m[K as a library.

2140+[35m[Ktests/syntax-tests/source/Erlang/bat_erlang.erl[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[K-module([1;33m[Kbat[m[K_erlang).

2141+[35m[Ktests/syntax-tests/source/Batch/LICENSE.md[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[KThe `build.[1;33m[Kbat[m[K` file has been added from https://github.com/Leandros/ClangOnWindows/blob/master/build.[1;33m[Kbat[m[K under the following license:

2143+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K# Repository: https://github.com/eth-p/[1;33m[Kbat[m[K-extras

2144+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K# Issues: https://github.com/eth-p/[1;33m[Kbat[m[K-extras/issues

2145+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K37[m[K[36m[K:[m[Kprintc "%{YELLOW}[%s warning]%{CLEAR}: $1%{CLEAR}\n" "[1;33m[Kbat[m[Kgrep" "${@:2}" 1>&2

2146+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K40[m[K[36m[K:[m[Kprintc "%{RED}[%s error]%{CLEAR}: $1%{CLEAR}\n" "[1;33m[Kbat[m[Kgrep" "${@:2}" 1>&2

2147+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K116[m[K[36m[K:[m[Kif [[ -n ${[1;33m[KBAT[m[K_PAGER+x} ]];then

2148+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K117[m[K[36m[K:[m[KSCRIPT_PAGER_CMD=($[1;33m[KBAT[m[K_PAGER)

2149+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K169[m[K[36m[K:[m[Kprintc "%{RED}%s: '%s' requires a value%{CLEAR}\n" "[1;33m[Kbat[m[Kgrep" "$ARG"

2150+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K185[m[K[36m[K:[m[K*)printc "%{RED}%s: '--color' expects value of 'auto', 'always', or 'never'%{CLEAR}\n" "[1;33m[Kbat[m[Kgrep"

2151+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K217[m[K[36m[K:[m[K*)printc "%{RED}%s: '--paging' expects value of 'auto', 'always', or 'never'%{CLEAR}\n" "[1;33m[Kbat[m[Kgrep"

2152+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K238[m[K[36m[K:[m[K"[1;33m[Kbat[m[Kgrep" \

2153+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K241[m[K[36m[K:[m[K"https://github.com/eth-p/[1;33m[Kbat[m[K-extras"

2154+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K269[m[K[36m[K:[m[K[1;33m[Kbat[m[K_version(){

2155+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K270[m[K[36m[K:[m[K"[1;33m[Kbat[m[K" --version|cut -d ' ' -f 2

2156+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K319[m[K[36m[K:[m[K[1;33m[KBAT[m[K_ARGS=()

2157+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K330[m[K[36m[K:[m[K[1;33m[KBAT[m[K_STYLE="header,numbers"

2158+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K331[m[K[36m[K:[m[Kif version_compare "$([1;33m[Kbat[m[K_version)" -gt "0.12";then

2159+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K419[m[K[36m[K:[m[Kprintc "%{RED}%s: unknown option '%s'%{CLEAR}\n" "[1;33m[Kbat[m[Kgrep" "$OPT" 1>&2

2160+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K444[m[K[36m[K:[m[K[1;33m[KBAT[m[K_ARGS+=("--color=always")

2161+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K446[m[K[36m[K:[m[K[1;33m[KBAT[m[K_ARGS+=("--color=never")

2162+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K462[m[K[36m[K:[m[K'the pager was explicitly disabled by $[1;33m[KBAT[m[K_PAGER or the' \

2163+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K482[m[K[36m[K:[m[K"[1;33m[Kbat[m[K" "${[1;33m[KBAT[m[K_ARGS[@]}" \

2164+[35m[Ktests/syntax-tests/source/Bash/batgrep.sh[m[K[36m[K:[m[K[32m[K485[m[K[36m[K:[m[K--style="$[1;33m[KBAT[m[K_STYLE$OPT_SNIP" \

2165+[35m[Ktests/syntax-tests/source/Bash/simple.sh[m[K[36m[K:[m[K[32m[K15[m[K[36m[K:[m[K | cat | [1;33m[Kbat[m[K - | cat

2166+[35m[Ktests/syntax-tests/source/Bash/simple.sh[m[K[36m[K:[m[K[32m[K20[m[K[36m[K:[m[Kif command -v [1;33m[Kbat[m[K &> /dev/null; then

2167+[35m[Ktests/syntax-tests/source/Rust/output.rs[m[K[36m[K:[m[K[32m[K39[m[K[36m[K:[m[K let pager_from_env = match (env::var("[1;33m[KBAT[m[K_PAGER"), env::var("PAGER")) {

2168+[35m[Ktests/syntax-tests/source/Rust/output.rs[m[K[36m[K:[m[K[32m[K40[m[K[36m[K:[m[K (Ok([1;33m[Kbat[m[K_pager), _) => Some([1;33m[Kbat[m[K_pager),

2169+[35m[Ktests/syntax-tests/source/Rust/output.rs[m[K[36m[K:[m[K[32m[K43[m[K[36m[K:[m[K // ANSI color sequences printed by [1;33m[Kbat[m[K. If someone has set PAGER="less -F", we

2170+[35m[Ktests/syntax-tests/source/Rust/output.rs[m[K[36m[K:[m[K[32m[K46[m[K[36m[K:[m[K // We only do this for PAGER (as it is not specific to '[1;33m[Kbat[m[K'), not for [1;33m[KBAT[m[K_PAGER

2171+[35m[Ktests/syntax-tests/source/Rust/output.rs[m[K[36m[K:[m[K[32m[K47[m[K[36m[K:[m[K // or [1;33m[Kbat[m[Ks '--pager' command line option.

2172+[35m[Ktests/syntax-tests/source/Rust/output.rs[m[K[36m[K:[m[K[32m[K71[m[K[36m[K:[m[K if pager_path.file_stem() == Some(&OsString::from("[1;33m[Kbat[m[K")) {

2173+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K6[m[K[36m[K:[m[K[1;33m[KBAT[m[K_CONFIG_DIR=$(mktemp -d)

2174+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K7[m[K[36m[K:[m[Kexport [1;33m[KBAT[m[K_CONFIG_DIR

2175+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K9[m[K[36m[K:[m[K[1;33m[KBAT[m[K_CACHE_PATH=$(mktemp -d)

2176+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K10[m[K[36m[K:[m[Kexport [1;33m[KBAT[m[K_CACHE_PATH

2177+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K13[m[K[36m[K:[m[K[1;33m[KBAT[m[K_CONFIG_DIR = ${[1;33m[KBAT[m[K_CONFIG_DIR}

2178+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K14[m[K[36m[K:[m[K[1;33m[KBAT[m[K_CACHE_PATH = ${[1;33m[KBAT[m[K_CACHE_PATH}

2179+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K20[m[K[36m[K:[m[K "--language=[1;33m[KBat[m[KTestCustomAssets"

2180+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[K "tests/syntax-tests/source/[1;33m[KBat[m[KTestCustomAssets/NoColorsUnlessCustomAssetsAreUsed.[1;33m[Kbat[m[Ktestcustomassets"

2181+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K42[m[K[36m[K:[m[Kecho_step "TEST: Make sure '[1;33m[KBat[m[KTestCustomAssets' is not part of integrated syntaxes"

2182+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K43[m[K[36m[K:[m[K[1;33m[Kbat[m[K -f "${custom_syntax_args[@]}" &&

2183+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K46[m[K[36m[K:[m[Kecho_step "PREPARE: Install custom syntax '[1;33m[KBat[m[KTestCustomAssets'"

2184+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K47[m[K[36m[K:[m[Kcustom_syntaxes_dir="$([1;33m[Kbat[m[K --config-dir)/syntaxes"

2185+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K49[m[K[36m[K:[m[Kcp -v "tests/syntax-tests/[1;33m[KBat[m[KTestCustomAssets.sublime-syntax" \

2186+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K50[m[K[36m[K:[m[K "${custom_syntaxes_dir}/[1;33m[KBat[m[KTestCustomAssets.sublime-syntax"

2187+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K52[m[K[36m[K:[m[Kecho_step "PREPARE: Build custom assets to enable '[1;33m[KBat[m[KTestCustomAssets' syntax"

2188+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K53[m[K[36m[K:[m[K[1;33m[Kbat[m[K cache --build

2189+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K55[m[K[36m[K:[m[Kecho_step "TEST: '[1;33m[KBat[m[KTestCustomAssets' is a known syntax"

2190+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K56[m[K[36m[K:[m[K[1;33m[Kbat[m[K -f "${custom_syntax_args[@]}" ||

2191+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K60[m[K[36m[K:[m[K[1;33m[Kbat[m[K -f "${integrated_syntax_args[@]}" ||

2192+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K63[m[K[36m[K:[m[Kecho_step "TEST: '[1;33m[KBat[m[KTestCustomAssets' is an unknown syntax with --no-custom-assets"

2193+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K64[m[K[36m[K:[m[K[1;33m[Kbat[m[K -f --no-custom-assets "${custom_syntax_args[@]}" &&

2194+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K67[m[K[36m[K:[m[Kecho_step "TEST: '[1;33m[Kbat[m[K cache --clear' removes all files"

2195+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K68[m[K[36m[K:[m[K[1;33m[Kbat[m[K cache --clear

2196+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K69[m[K[36m[K:[m[Kremaining_files=$(ls -A "${[1;33m[KBAT[m[K_CACHE_PATH}")

2197+[35m[Ktests/syntax-tests/test_custom_assets.sh[m[K[36m[K:[m[K[32m[K74[m[K[36m[K:[m[Krm -rv "${[1;33m[KBAT[m[K_CONFIG_DIR}" "${[1;33m[KBAT[m[K_CACHE_PATH}"

2198+[35m[Ktests/assets.rs[m[K[36m[K:[m[K[32m[K1[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::assets::HighlightingAssets;

2199+[35m[Ktests/no_duplicate_extensions.rs[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[Kuse [1;33m[Kbat[m[K::assets::HighlightingAssets;

2200+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[K# This script goes through all languages that are supported by '[1;33m[Kbat[m[K'. For each

2201+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K5[m[K[36m[K:[m[K# given folder for matching files. It calls '[1;33m[Kbat[m[K' for each of these files and

2202+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K8[m[K[36m[K:[m[K# execution of '[1;33m[Kbat[m[K'.

2203+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K11[m[K[36m[K:[m[K# - [1;33m[Kbat[m[K (in the $PATH)

2204+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K24[m[K[36m[K:[m[K# Maximum time we allow `[1;33m[Kbat[m[K` to run

2205+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K25[m[K[36m[K:[m[K[1;33m[KBAT[m[K_TIMEOUT_SEC = 10

2206+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K62[m[K[36m[K:[m[K sp.check_output(["[1;33m[Kbat[m[K", "--color=always", path], timeout=[1;33m[KBAT[m[K_TIMEOUT_SEC)

2207+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K77[m[K[36m[K:[m[K if num_chars < THRESHOLD_SPEED * [1;33m[KBAT[m[K_TIMEOUT_SEC:

2208+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K78[m[K[36m[K:[m[K print(f" Error: [1;33m[Kbat[m[K timed out on file '{path.decode()}'.")

2209+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K81[m[K[36m[K:[m[K f" Warning: [1;33m[Kbat[m[K timed out on file '{path.decode()} (but the file is large)."

2210+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K85[m[K[36m[K:[m[Kdef measure_[1;33m[Kbat[m[K_startup_speed():

2211+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K90[m[K[36m[K:[m[K ["[1;33m[Kbat[m[K", "--color=always", "--language=py"], stdin=sp.PIPE, stdout=sp.PIPE

2212+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K102[m[K[36m[K:[m[K output = sp.check_output(["[1;33m[Kbat[m[K", "--list-languages"]).decode()

2213+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K113[m[K[36m[K:[m[K print("Measuring '[1;33m[Kbat[m[K' startup speed ... ", flush=True, end="")

2214+[35m[Ktests/scripts/find-slow-to-highlight-files.py[m[K[36m[K:[m[K[32m[K114[m[K[36m[K:[m[K startup_time = measure_[1;33m[Kbat[m[K_startup_speed()

2215+[35m[Ktests/tester.rs[m[K[36m[K:[m[K[32m[K13[m[K[36m[K:[m[Kpub struct [1;33m[KBat[m[KTester {

2216+[35m[Ktests/tester.rs[m[K[36m[K:[m[K[32m[K17[m[K[36m[K:[m[K /// Path to the *[1;33m[Kbat[m[K* executable

2217+[35m[Ktests/tester.rs[m[K[36m[K:[m[K[32m[K21[m[K[36m[K:[m[Kimpl [1;33m[KBat[m[KTester {

2218+[35m[Ktests/tester.rs[m[K[36m[K:[m[K[32m[K35[m[K[36m[K:[m[K .expect("[1;33m[Kbat[m[K failed");

2219+[35m[Ktests/tester.rs[m[K[36m[K:[m[K[32m[K52[m[K[36m[K:[m[Kimpl Default for [1;33m[KBat[m[KTester {

2220+[35m[Ktests/tester.rs[m[K[36m[K:[m[K[32m[K61[m[K[36m[K:[m[K .expect("[1;33m[Kbat[m[K executable directory")

2221+[35m[Ktests/tester.rs[m[K[36m[K:[m[K[32m[K64[m[K[36m[K:[m[K let exe_name = if cfg!(windows) { "[1;33m[Kbat[m[K.exe" } else { "[1;33m[Kbat[m[K" };

2222+[35m[Ktests/tester.rs[m[K[36m[K:[m[K[32m[K67[m[K[36m[K:[m[K [1;33m[KBat[m[KTester { temp_dir, exe }

2223+[35m[Ktests/tester.rs[m[K[36m[K:[m[K[32m[K86[m[K[36m[K:[m[K let signature = Signature::now("[1;33m[Kbat[m[K test runner", "[1;33m[Kbat[m[K@test.runner")?;

2224+[35m[Ktests/snapshot_tests.rs[m[K[36m[K:[m[K[32m[K3[m[K[36m[K:[m[Kuse crate::tester::[1;33m[KBat[m[KTester;

2225+[35m[Ktests/snapshot_tests.rs[m[K[36m[K:[m[K[32m[K10[m[K[36m[K:[m[K let [1;33m[Kbat[m[K_tester = [1;33m[KBat[m[KTester::default();

2226+[35m[Ktests/snapshot_tests.rs[m[K[36m[K:[m[K[32m[K11[m[K[36m[K:[m[K [1;33m[Kbat[m[K_tester.test_snapshot(stringify!($test_name), $style);

2227+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K2[m[K[36m[K:[m[K_modules=('system' '[1;33m[Kbat[m[K' '[1;33m[Kbat[m[K_config' '[1;33m[Kbat[m[K_wrapper' '[1;33m[Kbat[m[K_wrapper_function' 'tool')

2228+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K10[m[K[36m[K:[m[K[1;33m[KBAT[m[K="[1;33m[Kbat[m[K"

2229+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K11[m[K[36m[K:[m[Kif ! command -v [1;33m[Kbat[m[K &>/dev/null; then

2230+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K12[m[K[36m[K:[m[K if command -v [1;33m[Kbat[m[Kcat &> /dev/null; then

2231+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K13[m[K[36m[K:[m[K [1;33m[KBAT[m[K="[1;33m[Kbat[m[Kcat"

2232+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K17[m[K[36m[K:[m[K "Unable to find a [1;33m[Kbat[m[K executable on your PATH." \

2233+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K18[m[K[36m[K:[m[K "Please ensure that '[1;33m[Kbat[m[K' exists and is not named something else."

2234+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K28[m[K[36m[K:[m[K_[1;33m[Kbat[m[K_:description() {

2235+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K29[m[K[36m[K:[m[K _collects "Version information for '[1;33m[Kbat[m[K'."

2236+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K30[m[K[36m[K:[m[K _collects "Custom syntaxes and themes for '[1;33m[Kbat[m[K'."

2237+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K33[m[K[36m[K:[m[K_[1;33m[Kbat[m[K_config_:description() {

2238+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K34[m[K[36m[K:[m[K _collects "The environment variables used by '[1;33m[Kbat[m[K'."

2239+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K35[m[K[36m[K:[m[K _collects "The '[1;33m[Kbat[m[K' configuration file."

2240+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K38[m[K[36m[K:[m[K_[1;33m[Kbat[m[K_wrapper_:description() {

2241+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K39[m[K[36m[K:[m[K _collects "Any wrapper script used by '[1;33m[Kbat[m[K'."

2242+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K42[m[K[36m[K:[m[K_[1;33m[Kbat[m[K_wrapper_function_:description() {

2243+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K43[m[K[36m[K:[m[K _collects "The wrapper function surrounding '[1;33m[Kbat[m[K' (if applicable)."

2244+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K57[m[K[36m[K:[m[K_[1;33m[Kbat[m[K_:run() {

2245+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K58[m[K[36m[K:[m[K _out "$[1;33m[KBAT[m[K" --version

2246+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K59[m[K[36m[K:[m[K _out env | grep '^[1;33m[KBAT[m[K_\|^PAGER='

2247+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K62[m[K[36m[K:[m[K cache_dir="$($[1;33m[KBAT[m[K --cache-dir)"

2248+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K64[m[K[36m[K:[m[K _print_command "$[1;33m[KBAT[m[K" "--list-languages"

2249+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K69[m[K[36m[K:[m[K _print_command "$[1;33m[KBAT[m[K" "--list-themes"

2250+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K74[m[K[36m[K:[m[K_[1;33m[Kbat[m[K_config_:run() {

2251+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K75[m[K[36m[K:[m[K if [[ -f "$("$[1;33m[KBAT[m[K" --config-file)" ]]; then

2252+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K76[m[K[36m[K:[m[K _out_fence cat "$("$[1;33m[KBAT[m[K" --config-file)"

2253+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K80[m[K[36m[K:[m[K_[1;33m[Kbat[m[K_wrapper_:run() {

2254+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K81[m[K[36m[K:[m[K _[1;33m[Kbat[m[K_wrapper_:detect_wrapper() {

2255+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K82[m[K[36m[K:[m[K local [1;33m[Kbat[m[K="$1"

2256+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K83[m[K[36m[K:[m[K if file "$(command -v "${[1;33m[Kbat[m[K}")" | grep "text executable" &> /dev/null; then

2257+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K84[m[K[36m[K:[m[K _out_fence cat "$(command -v "${[1;33m[Kbat[m[K}")"

2258+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K88[m[K[36m[K:[m[K printf "\nNo wrapper script for '%s'.\n" "${[1;33m[Kbat[m[K}"

2259+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K91[m[K[36m[K:[m[K _[1;33m[Kbat[m[K_wrapper_:detect_wrapper [1;33m[Kbat[m[K

2260+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K92[m[K[36m[K:[m[K if [[ "$[1;33m[KBAT[m[K" != "[1;33m[Kbat[m[K" ]]; then

2261+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K93[m[K[36m[K:[m[K _[1;33m[Kbat[m[K_wrapper_:detect_wrapper "$[1;33m[KBAT[m[K"

2262+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K97[m[K[36m[K:[m[K_[1;33m[Kbat[m[K_wrapper_function_:run() {

2263+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K98[m[K[36m[K:[m[K _[1;33m[Kbat[m[K_wrapper_function_:detect_wrapper() {

2264+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K125[m[K[36m[K:[m[K _[1;33m[Kbat[m[K_wrapper_function_:detect_wrapper [1;33m[Kbat[m[K

2265+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K126[m[K[36m[K:[m[K _[1;33m[Kbat[m[K_wrapper_function_:detect_wrapper cat

2266+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K127[m[K[36m[K:[m[K if [[ "$[1;33m[KBAT[m[K" != "[1;33m[Kbat[m[K" ]]; then

2267+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K128[m[K[36m[K:[m[K _[1;33m[Kbat[m[K_wrapper_function_:detect_wrapper "$[1;33m[KBAT[m[K"

2268+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K180[m[K[36m[K:[m[Ksystem and [1;33m[Kbat[m[K configuration. It will give you a small preview of the commands

2269+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K201[m[K[36m[K:[m[K | sed "s/\"\$[1;33m[KBAT[m[K\"/$[1;33m[KBAT[m[K/" 1>&2

2270+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K228[m[K[36m[K:[m[K# Tell the user if their executable isn't named "[1;33m[Kbat[m[K".

2271+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K229[m[K[36m[K:[m[Kif [[ "$[1;33m[KBAT[m[K" != "[1;33m[Kbat[m[K" ]] && [[ "$1" != '-y' ]]; then

2272+[35m[Kdiagnostics/info.sh[m[K[36m[K:[m[K[32m[K235[m[K[36m[K:[m[K printf "The %s executable on your system is named '%s'.\n%s\n" "[1;33m[Kbat[m[K" "$[1;33m[KBAT[m[K" \

tests/benchmarks/test-src/jquery-3.3.1.js → tests/benchmarks/highlighting-speed-src/jquery.jsrenamed

The content is the same.

tests/benchmarks/test-src/miniz.c → tests/benchmarks/highlighting-speed-src/miniz.crenamed

The content is the same.

tests/benchmarks/highlighting-speed-src/numpy_test_multiarray.pynew file+8471