assets/syntaxes/TypeScript.sublime-syntax · bat

1%YAML 1.2

2---

3# http://www.sublimetext.com/docs/3/syntax.html

4name: TypeScript

5file_extensions:

6 - ts

7scope: source.ts

8contexts:

9 main:

10 - include: directives

11 - include: statements

12 - match: \A(#!).*(?=$)

13 scope: comment.line.shebang.ts

14 captures:

15 1: punctuation.definition.comment.ts

16 comment:

17 - match: /\*\*(?!/)

18 captures:

19 0: punctuation.definition.comment.ts

20 push:

21 - meta_scope: comment.block.documentation.ts

22 - match: \*/

23 captures:

24 0: punctuation.definition.comment.ts

25 pop: true

26 - include: docblock

27 - match: (/\*)(?:\s*((@)internal)(?=\s|(\*/)))?

28 captures:

29 1: punctuation.definition.comment.ts

30 2: storage.type.internaldeclaration.ts

31 3: punctuation.decorator.internaldeclaration.ts

32 push:

33 - meta_scope: comment.block.ts

34 - match: \*/

35 captures:

36 0: punctuation.definition.comment.ts

37 pop: true

38 - match: '(^[ \t]+)?((//)(?:\s*((@)internal)(?=\s|$))?)'

39 captures:

40 1: punctuation.whitespace.comment.leading.ts

41 2: comment.line.double-slash.ts

42 3: punctuation.definition.comment.ts

43 4: storage.type.internaldeclaration.ts

44 5: punctuation.decorator.internaldeclaration.ts

45 push:

46 - meta_content_scope: comment.line.double-slash.ts

47 - match: (?=^)

48 pop: true

49 access-modifier:

51 scope: storage.modifier.ts

52 after-operator-block-as-object-literal:

53 - match: '(?<!\+\+|--)(?<=[:=(,\[?+!>]|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^yield|[^\._$[:alnum:]]yield|^throw|[^\._$[:alnum:]]throw|^in|[^\._$[:alnum:]]in|^of|[^\._$[:alnum:]]of|^typeof|[^\._$[:alnum:]]typeof|&&|\|\||\*)\s*(\{)'

54 captures:

55 1: punctuation.definition.block.ts

56 push:

57 - meta_scope: meta.objectliteral.ts

58 - match: '\}'

59 captures:

60 0: punctuation.definition.block.ts

61 pop: true

62 - include: object-member

63 array-binding-pattern:

64 - match: '(?:(\.\.\.)\s*)?(\[)'

65 captures:

66 1: keyword.operator.rest.ts

67 2: punctuation.definition.binding-pattern.array.ts

68 push:

69 - match: '\]'

70 captures:

71 0: punctuation.definition.binding-pattern.array.ts

72 pop: true

73 - include: binding-element

74 - include: punctuation-comma

75 array-binding-pattern-const:

76 - match: '(?:(\.\.\.)\s*)?(\[)'

77 captures:

78 1: keyword.operator.rest.ts

79 2: punctuation.definition.binding-pattern.array.ts

80 push:

81 - match: '\]'

82 captures:

83 0: punctuation.definition.binding-pattern.array.ts

84 pop: true

85 - include: binding-element-const

86 - include: punctuation-comma

87 array-literal:

88 - match: '\s*(\[)'

89 captures:

90 1: meta.brace.square.ts

91 push:

92 - meta_scope: meta.array.literal.ts

93 - match: '\]'

94 captures:

95 0: meta.brace.square.ts

96 pop: true

97 - include: expression

98 - include: punctuation-comma

99 arrow-function:

100 - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync)\s+)?([_$[:alpha:]][_$[:alnum:]]*)\s*(?==>)'

101 scope: meta.arrow.ts

102 captures:

103 1: storage.modifier.async.ts

104 2: variable.parameter.ts

105 - match: |-

106 (?x) (?:

107 (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync)

108 )? ((?<![})!\]])\s*

109 (?=

110 # sure shot arrow functions even if => is on new line

111 (

112 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

113 [(]\s*

114 (

115 ([)]\s*:) | # ():

116 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

117 )

118 ) |

119 (

120 [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

121 ) |

122 # arrow function possible to detect only with => on same line

123 (

124 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

125 $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

126 (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

127 \s*=> # arrow operator

128 )

129 )

130 )

131 captures:

132 1: storage.modifier.async.ts

133 push:

134 - meta_scope: meta.arrow.ts

135 - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))'

136 pop: true

137 - include: comment

138 - include: type-parameters

139 - include: function-parameters

140 - include: arrow-return-type

141 - match: "=>"

142 captures:

143 0: storage.type.function.arrow.ts

144 push:

145 - meta_scope: meta.arrow.ts

146 - match: '(?<=\}|\S)(?<!=>)|((?!\{)(?=\S))'

147 pop: true

148 - include: decl-block

149 - include: expression

150 arrow-return-type:

151 - match: (?<=\))\s*(:)

152 captures:

153 1: keyword.operator.type.annotation.ts

154 push:

155 - meta_scope: meta.return.type.arrow.ts

156 - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))'

157 pop: true

158 - include: arrow-return-type-body

159 arrow-return-type-body:

160 - match: '(?<=[:])(?=\s*\{)'

161 push:

162 - match: '(?<=\})'

163 pop: true

164 - include: type-object

165 - include: type-predicate-operator

166 - include: type

167 async-modifier:

168 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(async)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

169 scope: storage.modifier.async.ts

170 binding-element:

171 - include: comment

172 - include: string

173 - include: object-binding-pattern

174 - include: array-binding-pattern

175 - include: destructuring-variable-rest

176 - include: variable-initializer

177 binding-element-const:

178 - include: comment

179 - include: string

180 - include: object-binding-pattern-const

181 - include: array-binding-pattern-const

182 - include: destructuring-variable-rest-const

183 - include: variable-initializer

184 boolean-literal:

185 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))true(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

186 scope: constant.language.boolean.true.ts

187 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))false(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

188 scope: constant.language.boolean.false.ts

189 brackets:

190 - match: "{"

191 push:

192 - match: '}|(?=\*/)'

193 pop: true

194 - include: brackets

195 - match: '\['

196 push:

197 - match: '\]|(?=\*/)'

198 pop: true

199 - include: brackets

200 cast:

202 captures:

203 1: meta.brace.angle.ts

204 push:

205 - meta_scope: cast.expr.ts

206 - match: (\>)\s*

207 captures:

208 1: meta.brace.angle.ts

209 pop: true

210 - include: type

211 - match: '(?:(?<=^))\s*(<)(?=[_$[:alpha:]][_$[:alnum:]]*\s*>)'

212 captures:

213 1: meta.brace.angle.ts

214 push:

215 - meta_scope: cast.expr.ts

216 - match: (\>)\s*

217 captures:

218 1: meta.brace.angle.ts

219 pop: true

220 - include: type

221 class-declaration:

222 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(export)\s+)?\b(?:(abstract)\s+)?\b(class)\b(?=\s+|/[/*])'

223 captures:

224 1: keyword.control.export.ts

225 2: storage.modifier.ts

226 3: storage.type.class.ts

227 push:

228 - meta_scope: meta.class.ts

229 - match: '(?<=\})'

230 pop: true

231 - include: class-declaration-or-expression-patterns

232 class-declaration-or-expression-patterns:

233 - include: comment

234 - include: class-or-interface-heritage

235 - match: "[_$[:alpha:]][_$[:alnum:]]*"

236 captures:

237 0: entity.name.type.class.ts

238 - include: type-parameters

239 - include: class-or-interface-body

240 class-expression:

241 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(class)\b(?=\s+|[<{]|\/[\/*])'

242 captures:

243 1: storage.type.class.ts

244 push:

245 - meta_scope: meta.class.ts

246 - match: '(?<=\})'

247 pop: true

248 - include: class-declaration-or-expression-patterns

249 class-or-interface-body:

250 - match: '\{'

251 captures:

252 0: punctuation.definition.block.ts

253 push:

254 - match: '\}'

255 captures:

256 0: punctuation.definition.block.ts

257 pop: true

258 - include: comment

259 - include: decorator

260 - include: method-declaration

261 - include: indexer-declaration

262 - include: field-declaration

263 - include: string

264 - include: type-annotation

265 - include: variable-initializer

266 - include: access-modifier

267 - include: property-accessor

268 - include: async-modifier

269 - include: after-operator-block-as-object-literal

270 - include: decl-block

271 - include: expression

272 - include: punctuation-comma

273 - include: punctuation-semicolon

274 class-or-interface-heritage:

275 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(extends|implements)\b)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

276 captures:

277 1: storage.modifier.ts

278 push:

279 - match: '(?=\{)'

280 pop: true

281 - include: comment

282 - include: class-or-interface-heritage

283 - include: type-parameters

284 - include: expressionWithoutIdentifiers

285 - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))(?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)*\s*)'

286 captures:

287 1: entity.name.type.module.ts

288 2: punctuation.accessor.ts

289 3: punctuation.accessor.optional.ts

290 - match: "([_$[:alpha:]][_$[:alnum:]]*)"

291 captures:

292 1: entity.other.inherited-class.ts

293 - include: expressionPunctuations

294 control-statement:

295 - include: switch-statement

296 - include: for-loop

298 scope: keyword.control.trycatch.ts

299 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(break|continue|goto)\s+([_$[:alpha:]][_$[:alnum:]]*)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

300 captures:

301 1: keyword.control.loop.ts

302 2: entity.name.label.ts

304 scope: keyword.control.loop.ts

305 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(return)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

306 scope: keyword.control.flow.ts

307 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default|switch)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

308 scope: keyword.control.switch.ts

309 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(else|if)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

310 scope: keyword.control.conditional.ts

311 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(with)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

312 scope: keyword.control.with.ts

313 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(package)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

314 scope: keyword.control.ts

315 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(debugger)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

316 scope: keyword.other.debugger.ts

317 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(declare)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

318 scope: storage.modifier.ts

319 decl-block:

320 - match: '\{'

321 captures:

322 0: punctuation.definition.block.ts

323 push:

324 - meta_scope: meta.block.ts

325 - match: '\}'

326 captures:

327 0: punctuation.definition.block.ts

328 pop: true

329 - include: statements

330 declaration:

331 - include: decorator

332 - include: var-expr

333 - include: function-declaration

334 - include: class-declaration

335 - include: interface-declaration

336 - include: enum-declaration

337 - include: namespace-declaration

338 - include: type-alias-declaration

339 - include: import-equals-declaration

340 - include: import-declaration

341 - include: export-declaration

342 decorator:

343 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))\@'

344 captures:

345 0: punctuation.decorator.ts

346 push:

347 - meta_scope: meta.decorator.ts

348 - match: (?=\s)

349 pop: true

350 - include: expression

351 destructuring-const:

352 - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\{)'

353 push:

354 - meta_scope: meta.object-binding-pattern-variable.ts

355 - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

356 pop: true

357 - include: object-binding-pattern-const

358 - include: type-annotation

359 - include: comment

360 - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\[)'

361 push:

362 - meta_scope: meta.array-binding-pattern-variable.ts

363 - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

364 pop: true

365 - include: array-binding-pattern-const

366 - include: type-annotation

367 - include: comment

368 destructuring-parameter:

369 - match: '(?<!=|:)\s*(\{)'

370 captures:

371 1: punctuation.definition.binding-pattern.object.ts

372 push:

373 - meta_scope: meta.parameter.object-binding-pattern.ts

374 - match: '\}'

375 captures:

376 0: punctuation.definition.binding-pattern.object.ts

377 pop: true

378 - include: parameter-object-binding-element

379 - match: '(?<!=|:)\s*(\[)'

380 captures:

381 1: punctuation.definition.binding-pattern.array.ts

382 push:

383 - meta_scope: meta.paramter.array-binding-pattern.ts

384 - match: '\]'

385 captures:

386 0: punctuation.definition.binding-pattern.array.ts

387 pop: true

388 - include: parameter-binding-element

389 - include: punctuation-comma

390 destructuring-parameter-rest:

391 - match: '(?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*)'

392 captures:

393 1: keyword.operator.rest.ts

394 2: variable.parameter.ts

395 destructuring-variable:

396 - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\{)'

397 push:

398 - meta_scope: meta.object-binding-pattern-variable.ts

399 - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

400 pop: true

401 - include: object-binding-pattern

402 - include: type-annotation

403 - include: comment

404 - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\[)'

405 push:

406 - meta_scope: meta.array-binding-pattern-variable.ts

407 - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

408 pop: true

409 - include: array-binding-pattern

410 - include: type-annotation

411 - include: comment

412 destructuring-variable-rest:

413 - match: '(?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*)'

414 captures:

415 1: keyword.operator.rest.ts

416 2: meta.definition.variable.ts variable.other.readwrite.ts

417 destructuring-variable-rest-const:

418 - match: '(?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*)'

419 captures:

420 1: keyword.operator.rest.ts

421 2: meta.definition.variable.ts variable.other.constant.ts

422 directives:

423 - match: '^(///)\s*(?=<(reference|amd-dependency|amd-module)(\s+(path|types|no-default-lib|lib|name)\s*=\s*((\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")))+\s*/>\s*$)'

424 captures:

425 1: punctuation.definition.comment.ts

426 push:

427 - meta_scope: comment.line.triple-slash.directive.ts

428 - match: (?=^)

429 pop: true

430 - match: (<)(reference|amd-dependency|amd-module)

431 captures:

432 1: punctuation.definition.tag.directive.ts

433 2: entity.name.tag.directive.ts

434 push:

435 - meta_scope: meta.tag.ts

436 - match: />

437 captures:

438 0: punctuation.definition.tag.directive.ts

439 pop: true

440 - match: path|types|no-default-lib|lib|name

441 scope: entity.other.attribute-name.directive.ts

442 - match: "="

443 scope: keyword.operator.assignment.ts

444 - include: string

445 docblock:

446 - match: |-

447 (?x)

448 ((@)(?:access|api))

449 \s+

450 (private|protected|public)

451 \b

452 captures:

453 1: storage.type.class.jsdoc

454 2: punctuation.definition.block.tag.jsdoc

455 3: constant.language.access-type.jsdoc

456 - match: |-

457 (?x)

458 ((@)author)

459 \s+

460 (

461 [^@\s<>*/]

462 (?:[^@<>*/]|\*[^/])*

463 )

464 (?:

465 \s*

466 (<)

467 ([^>\s]+)

468 (>)

469 )?

470 captures:

471 1: storage.type.class.jsdoc

472 2: punctuation.definition.block.tag.jsdoc

473 3: entity.name.type.instance.jsdoc

474 4: punctuation.definition.bracket.angle.begin.jsdoc

475 5: constant.other.email.link.underline.jsdoc

476 6: punctuation.definition.bracket.angle.end.jsdoc

477 - match: |-

478 (?x)

479 ((@)borrows) \s+

480 ((?:[^@\s*/]|\*[^/])+) # <that namepath>

481 \s+ (as) \s+ # as

482 ((?:[^@\s*/]|\*[^/])+) # <this namepath>

483 captures:

484 1: storage.type.class.jsdoc

485 2: punctuation.definition.block.tag.jsdoc

486 3: entity.name.type.instance.jsdoc

487 4: keyword.operator.control.jsdoc

488 5: entity.name.type.instance.jsdoc

489 - match: ((@)example)\s+

490 captures:

491 1: storage.type.class.jsdoc

492 2: punctuation.definition.block.tag.jsdoc

493 push:

494 - meta_scope: meta.example.jsdoc

495 - match: (?=@|\*/)

496 pop: true

497 - match: ^\s\*\s+

498 - match: \G(<)caption(>)

499 captures:

500 0: entity.name.tag.inline.jsdoc

501 1: punctuation.definition.bracket.angle.begin.jsdoc

502 2: punctuation.definition.bracket.angle.end.jsdoc

503 push:

504 - meta_content_scope: constant.other.description.jsdoc

505 - match: (</)caption(>)|(?=\*/)

506 captures:

507 0: entity.name.tag.inline.jsdoc

508 1: punctuation.definition.bracket.angle.begin.jsdoc

509 2: punctuation.definition.bracket.angle.end.jsdoc

510 pop: true

511 - match: '[^\s@*](?:[^*]|\*[^/])*'

512 captures:

513 0: source.embedded.ts

515 captures:

516 1: storage.type.class.jsdoc

517 2: punctuation.definition.block.tag.jsdoc

518 3: constant.language.symbol-type.jsdoc

519 - match: |-

520 (?x)

521 ((@)see)

522 \s+

523 (?:

524 # URL

525 (

526 (?=https?://)

527 (?:[^\s*]|\*[^/])+

528 )

529 |

530 # JSDoc namepath

531 (

532 (?!

533 # Avoid matching bare URIs (also acceptable as links)

534 https?://

535 |

536 # Avoid matching {@inline tags}; we match those below

537 (?:\[[^\[\]]*\])? # Possible description [preceding]{@tag}

538 {@(?:link|linkcode|linkplain|tutorial)\b

539 )

540 # Matched namepath

541 (?:[^@\s*/]|\*[^/])+

542 )

543 )

544 captures:

545 1: storage.type.class.jsdoc

546 2: punctuation.definition.block.tag.jsdoc

547 3: variable.other.link.underline.jsdoc

548 4: entity.name.type.instance.jsdoc

549 - match: |-

550 (?x)

551 ((@)template)

552 \s+

553 # One or more valid identifiers

554 (

555 [A-Za-z_$] # First character: non-numeric word character

556 [\w$.\[\]]* # Rest of identifier

557 (?: # Possible list of additional identifiers

558 \s* , \s*

559 [A-Za-z_$]

560 [\w$.\[\]]*

561 )*

562 )

563 captures:

564 1: storage.type.class.jsdoc

565 2: punctuation.definition.block.tag.jsdoc

566 3: variable.other.jsdoc

567 - match: |-

568 (?x)

569 (

570 (@)

572 )

573 \s+

574 (

575 [A-Za-z_$]

576 [\w$.\[\]]*

577 )

578 captures:

579 1: storage.type.class.jsdoc

580 2: punctuation.definition.block.tag.jsdoc

581 3: variable.other.jsdoc

582 - match: '((@)typedef)\s+(?={)'

583 captures:

584 1: storage.type.class.jsdoc

585 2: punctuation.definition.block.tag.jsdoc

586 push:

587 - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])'

588 pop: true

589 - include: jsdoctype

590 - match: '(?:[^@\s*/]|\*[^/])+'

591 scope: entity.name.type.instance.jsdoc

592 - match: '((@)(?:arg|argument|const|constant|member|namespace|param|prop|property|var))\s+(?={)'

593 captures:

594 1: storage.type.class.jsdoc

595 2: punctuation.definition.block.tag.jsdoc

596 push:

597 - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])'

598 pop: true

599 - include: jsdoctype

600 - match: '([A-Za-z_$][\w$.\[\]]*)'

601 scope: variable.other.jsdoc

602 - match: |-

603 (?x)

604 (\[)\s*

605 [\w$]+

606 (?:

607 (?:\[\])? # Foo[ ].bar properties within an array

608 \. # Foo.Bar namespaced parameter

609 [\w$]+

610 )*

611 (?:

612 \s*

613 (=) # [foo=bar] Default parameter value

614 \s*

615 (

616 # The inner regexes are to stop the match early at */ and to not stop at escaped quotes

617 (?>

618 "(?:(?:\*(?!/))|(?:\\(?!"))|[^*\\])*?" | # [foo="bar"] Double-quoted

619 '(?:(?:\*(?!/))|(?:\\(?!'))|[^*\\])*?' | # [foo='bar'] Single-quoted

620 \[ (?:(?:\*(?!/))|[^*])*? \] | # [foo=[1,2]] Array literal

621 (?:(?:\*(?!/))|\s(?!\s*\])|\[.*?(?:\]|(?=\*/))|[^*\s\[\]])* # Everything else

622 )*

623 )

624 )?

625 \s*(?:(\])((?:[^*\s]|\*[^\s/])+)?|(?=\*/))

626 scope: variable.other.jsdoc

627 captures:

628 1: punctuation.definition.optional-value.begin.bracket.square.jsdoc

629 2: keyword.operator.assignment.jsdoc

630 3: source.embedded.ts

631 4: punctuation.definition.optional-value.end.bracket.square.jsdoc

632 5: invalid.illegal.syntax.jsdoc

633 - match: |-

634 (?x)

635 (

636 (@)

639 |yields?)

640 )

641 \s+(?={)

642 captures:

643 1: storage.type.class.jsdoc

644 2: punctuation.definition.block.tag.jsdoc

645 push:

646 - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])'

647 pop: true

648 - include: jsdoctype

649 - match: |-

650 (?x)

651 (

652 (@)

656 )

657 \s+

658 (

659 (?:

660 [^{}@\s*] | \*[^/]

661 )+

662 )

663 captures:

664 1: storage.type.class.jsdoc

665 2: punctuation.definition.block.tag.jsdoc

666 3: entity.name.type.instance.jsdoc

667 - match: '((@)(?:default(?:value)?|license|version))\s+(([''''"]))'

668 captures:

669 1: storage.type.class.jsdoc

670 2: punctuation.definition.block.tag.jsdoc

671 3: variable.other.jsdoc

672 4: punctuation.definition.string.begin.jsdoc

673 push:

674 - meta_content_scope: variable.other.jsdoc

675 - match: (\3)|(?=$|\*/)

676 captures:

677 0: variable.other.jsdoc

678 1: punctuation.definition.string.end.jsdoc

679 pop: true

680 - match: '((@)(?:default(?:value)?|license|tutorial|variation|version))\s+([^\s*]+)'

681 captures:

682 1: storage.type.class.jsdoc

683 2: punctuation.definition.block.tag.jsdoc

684 3: variable.other.jsdoc

686 scope: storage.type.class.jsdoc

687 captures:

688 1: punctuation.definition.block.tag.jsdoc

689 - include: inline-tags

690 enum-declaration:

691 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:\b(const)\s+)?\b(enum)\s+([_$[:alpha:]][_$[:alnum:]]*)'

692 captures:

693 1: keyword.control.export.ts

694 2: storage.modifier.ts

695 3: storage.type.enum.ts

696 4: entity.name.type.enum.ts

697 push:

698 - meta_scope: meta.enum.declaration.ts

699 - match: '(?<=\})'

700 pop: true

701 - include: comment

702 - match: '\{'

703 captures:

704 0: punctuation.definition.block.ts

705 push:

706 - match: '\}'

707 captures:

708 0: punctuation.definition.block.ts

709 pop: true

710 - include: comment

711 - match: "([_$[:alpha:]][_$[:alnum:]]*)"

712 captures:

713 0: variable.other.enummember.ts

714 push:

715 - match: '(?=,|\}|$)'

716 pop: true

717 - include: comment

718 - include: variable-initializer

719 - match: '(?=((\''([^\''\\]|\\\''|\\)*\'')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\])))'

720 push:

721 - match: '(?=,|\}|$)'

722 pop: true

723 - include: string

724 - include: array-literal

725 - include: comment

726 - include: variable-initializer

727 - include: punctuation-comma

728 export-declaration:

729 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)\s+(as)\s+(namespace)\s+([_$[:alpha:]][_$[:alnum:]]*)'

730 captures:

731 1: keyword.control.export.ts

732 2: keyword.control.as.ts

733 3: storage.type.namespace.ts

734 4: entity.name.type.module.ts

735 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:(?:\s*(=))|(?:\s+(default)(?=\s+)))'

736 captures:

737 1: keyword.control.export.ts

738 2: keyword.operator.assignment.ts

739 3: keyword.control.default.ts

740 push:

741 - meta_scope: meta.export.default.ts

743 pop: true

744 - include: expression

745 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?!\s*:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

746 captures:

747 0: keyword.control.export.ts

748 push:

749 - meta_scope: meta.export.ts

751 pop: true

752 - include: import-export-declaration

753 expression:

754 - include: expressionWithoutIdentifiers

755 - include: identifiers

756 - include: expressionPunctuations

757 expression-inside-possibly-arrow-parens:

758 - include: expressionWithoutIdentifiers

759 - include: function-parameters-body

760 - include: identifiers

761 - include: expressionPunctuations

762 expression-operators:

763 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(await)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

764 scope: keyword.control.flow.ts

765 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(yield)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?=\s*\/\*([^\*]|(\*[^\/]))*\*\/\s*\*)'

766 captures:

767 1: keyword.control.flow.ts

768 push:

769 - match: \*

770 captures:

771 0: keyword.generator.asterisk.ts

772 pop: true

773 - include: comment

774 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(yield)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?:\s*(\*))?'

775 captures:

776 1: keyword.control.flow.ts

777 2: keyword.generator.asterisk.ts

778 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))delete(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

779 scope: keyword.operator.expression.delete.ts

780 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))in(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?!\()'

781 scope: keyword.operator.expression.in.ts

782 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))of(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?!\()'

783 scope: keyword.operator.expression.of.ts

784 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))instanceof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

785 scope: keyword.operator.expression.instanceof.ts

786 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

787 scope: keyword.operator.new.ts

788 - include: typeof-operator

789 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))void(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

790 scope: keyword.operator.expression.void.ts

791 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+'

792 captures:

793 1: keyword.control.as.ts

794 push:

795 - match: '(?=$|^|[;,:})\]]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+))'

796 pop: true

797 - include: type

798 - match: \.\.\.

799 scope: keyword.operator.spread.ts

800 - match: \*=|(?<!\()/=|%=|\+=|\-=

801 scope: keyword.operator.assignment.compound.ts

802 - match: \&=|\^=|<<=|>>=|>>>=|\|=

803 scope: keyword.operator.assignment.compound.bitwise.ts

804 - match: "<<|>>>|>>"

805 scope: keyword.operator.bitwise.shift.ts

806 - match: "===|!==|==|!="

807 scope: keyword.operator.comparison.ts

808 - match: <=|>=|<>|<|>

809 scope: keyword.operator.relational.ts

810 - match: \!|&&|\|\|

811 scope: keyword.operator.logical.ts

812 - match: \&|~|\^|\|

813 scope: keyword.operator.bitwise.ts

814 - match: \=

815 scope: keyword.operator.assignment.ts

816 - match: "--"

817 scope: keyword.operator.decrement.ts

818 - match: \+\+

819 scope: keyword.operator.increment.ts

820 - match: '%|\*|/|-|\+'

821 scope: keyword.operator.arithmetic.ts

822 - match: '(?<=[_$[:alnum:])\]])\s*(/)(?![/*])'

823 captures:

824 1: keyword.operator.arithmetic.ts

825 expressionPunctuations:

826 - include: punctuation-comma

827 - include: punctuation-accessor

828 expressionWithoutIdentifiers:

829 - include: string

830 - include: regex

831 - include: template

832 - include: comment

833 - include: function-expression

834 - include: class-expression

835 - include: arrow-function

836 - include: paren-expression-possibly-arrow

837 - include: cast

838 - include: ternary-expression

839 - include: new-expr

840 - include: instanceof-expr

841 - include: object-literal

842 - include: expression-operators

843 - include: function-call

844 - include: literal

845 - include: support-objects

846 - include: paren-expression

847 field-declaration:

848 - match: |-

849 (?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(?!\$))|((?<!\$)(?:

850 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

851 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

852 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

853 (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

854 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

855 (?:\b[0-9][0-9_]*(\.)\B)| # 1.

856 (?:\B(\.)[0-9][0-9_]*\b)| # .1

857 (?:\b[0-9][0-9_]*\b(?!\.)) # 1

858 )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))

859 captures:

860 1: storage.modifier.ts

861 push:

862 - meta_scope: meta.field.declaration.ts

863 - match: |-

864 (?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(?!\$))|((?<!\$)(?:

865 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

866 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

867 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

868 (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

869 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

870 (?:\b[0-9][0-9_]*(\.)\B)| # 1.

871 (?:\B(\.)[0-9][0-9_]*\b)| # .1

872 (?:\b[0-9][0-9_]*\b(?!\.)) # 1

873 )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))))|(?<=\})

874 pop: true

875 - include: variable-initializer

876 - match: |-

877 (?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(?!\$))|((?<!\$)(?:

878 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

879 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

880 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

881 (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

882 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

883 (?:\b[0-9][0-9_]*(\.)\B)| # 1.

884 (?:\B(\.)[0-9][0-9_]*\b)| # .1

885 (?:\b[0-9][0-9_]*\b(?!\.)) # 1

886 )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))

887 push:

888 - match: |-

889 (?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(?!\$))|((?<!\$)(?:

890 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

891 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

892 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

893 (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

894 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

895 (?:\b[0-9][0-9_]*(\.)\B)| # 1.

896 (?:\B(\.)[0-9][0-9_]*\b)| # .1

897 (?:\b[0-9][0-9_]*\b(?!\.)) # 1

898 )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\?\s*)?(=|:))))|(?<=\})

899 pop: true

900 - include: type-annotation

901 - include: string

902 - include: array-literal

903 - include: numeric-literal

904 - include: comment

905 - match: |-

906 (?x)([_$[:alpha:]][_$[:alnum:]]*)(\?)?(?=(\?\s*)?\s*

907 # function assignment |

908 (=\s*(

909 ((async\s+)?(

910 (function\s*[(<*]) |

911 (function\s+) |

912 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

913 )) |

914 ((async\s*)?(

915 ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$)) |

916 # sure shot arrow functions even if => is on new line

917 (

918 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

919 [(]\s*

920 (

921 ([)]\s*:) | # ():

922 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

923 )

924 ) |

925 (

926 [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

927 ) |

928 # arrow function possible to detect only with => on same line

929 (

930 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

931 $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

932 (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

933 \s*=> # arrow operator

934 )

935 ))

936 )) |

938 (:\s*(

939 (<) |

940 ([(]\s*(

941 ([)]) |

942 (\.\.\.) |

943 ([_$[:alnum:]]+\s*(

944 ([:,?=])|

945 ([)]\s*=>)

946 ))

947 ))

948 )) |

949 (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$))) |

950 (:\s*(=>|($([^\($]|($[^\($]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

951 ((async\s+)?(

952 (function\s*[(<*]) |

953 (function\s+) |

954 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

955 )) |

956 ((async\s*)?(

957 ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$)) |

958 # sure shot arrow functions even if => is on new line

959 (

960 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

961 [(]\s*

962 (

963 ([)]\s*:) | # ():

964 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

965 )

966 ) |

967 (

968 [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

969 ) |

970 # arrow function possible to detect only with => on same line

971 (

972 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

973 $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

974 (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

975 \s*=> # arrow operator

976 )

977 ))

978 )))

979 captures:

980 1: meta.definition.property.ts entity.name.function.ts

981 2: keyword.operator.optional.ts

982 - match: "[_$[:alpha:]][_$[:alnum:]]*"

983 scope: meta.definition.property.ts variable.object.property.ts

984 - match: \?

985 scope: keyword.operator.optional.ts

986 for-loop:

987 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))for(?=((\s+|(\s*\/\*([^\*]|(\*[^\/]))*\*\/\s*))await)?\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)?(\())'

988 captures:

989 0: keyword.control.loop.ts

990 push:

991 - match: (?<=\))

992 pop: true

993 - include: comment

994 - match: await

995 scope: keyword.control.loop.ts

996 - match: \(

997 captures:

998 0: meta.brace.round.ts

999 push:

1000 - match: \)

1001 captures:

1002 0: meta.brace.round.ts

1003 pop: true

1004 - include: var-expr

1005 - include: expression

1006 - include: punctuation-semicolon

1007 function-body:

1008 - include: comment

1009 - include: type-parameters

1010 - include: function-parameters

1011 - include: return-type

1012 - include: decl-block

1013 - match: \*

1014 scope: keyword.generator.asterisk.ts

1015 function-call:

1016 - 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*)?\()'

1017 push:

1018 - 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*)?\()'

1019 pop: true

1020 - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*))'

1021 push:

1022 - meta_scope: meta.function-call.ts

1023 - match: '(?=\s*(\?\.\s*)?(<\s*(((keyof|infer)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))(?=\s*([\<\>\,\.\[=]|&(?!&)|\|(?!\|)))))([^<>$]|(\(([^\($]|($[^\($]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))(?=\s*([\<\>\,\.\[=]|&(?!&)|\|(?!\|)))))([^<>$]|(\(([^\($]|($[^\($]*\)))*\))|(?<==)\>)*(?!=)\>)*(?!=)>\s*)?\()'

1024 pop: true

1025 - include: literal

1026 - include: support-objects

1027 - include: object-identifiers

1028 - include: punctuation-accessor

1029 - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*[\(]\s*[\"\''\`]))'

1030 scope: keyword.operator.expression.import.ts

1031 - match: "([_$[:alpha:]][_$[:alnum:]]*)"

1032 scope: entity.name.function.ts

1033 - include: comment

1034 - match: \?\.

1035 scope: meta.function-call.ts punctuation.accessor.optional.ts

1036 - include: type-arguments

1037 - include: paren-expression

1038 function-declaration:

1039 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(export)\s+)?(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'

1040 captures:

1041 1: keyword.control.export.ts

1042 2: storage.modifier.async.ts

1043 3: storage.type.function.ts

1044 4: keyword.generator.asterisk.ts

1045 5: meta.definition.function.ts entity.name.function.ts

1046 push:

1047 - meta_scope: meta.function.ts

1048 - match: '(?=$|^|;)|(?<=\})'

1049 pop: true

1050 - include: function-name

1051 - include: function-body

1052 function-expression:

1053 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'

1054 captures:

1055 1: storage.modifier.async.ts

1056 2: storage.type.function.ts

1057 3: keyword.generator.asterisk.ts

1058 4: meta.definition.function.ts entity.name.function.ts

1059 push:

1060 - meta_scope: meta.function.expression.ts

1061 - match: '(?<=\})'

1062 pop: true

1063 - include: function-name

1064 - include: function-body

1065 function-name:

1066 - match: "[_$[:alpha:]][_$[:alnum:]]*"

1067 scope: meta.definition.function.ts entity.name.function.ts

1068 function-parameters:

1069 - match: \(

1070 captures:

1071 0: punctuation.definition.parameters.begin.ts

1072 push:

1073 - meta_scope: meta.parameters.ts

1074 - match: \)

1075 captures:

1076 0: punctuation.definition.parameters.end.ts

1077 pop: true

1078 - include: function-parameters-body

1079 function-parameters-body:

1080 - include: comment

1081 - include: decorator

1082 - include: destructuring-parameter

1083 - include: parameter-name

1084 - include: type-annotation

1085 - include: variable-initializer

1086 - match: ","

1087 scope: punctuation.separator.parameter.ts

1088 identifiers:

1089 - include: object-identifiers

1090 - match: |-

1091 (?x)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*)?([_$[:alpha:]][_$[:alnum:]]*)(?=\s*=\s*(

1092 ((async\s+)?(

1093 (function\s*[(<*]) |

1094 (function\s+) |

1095 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

1096 )) |

1097 ((async\s*)?(

1098 ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$)) |

1099 # sure shot arrow functions even if => is on new line

1100 (

1101 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

1102 [(]\s*

1103 (

1104 ([)]\s*:) | # ():

1105 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

1106 )

1107 ) |

1108 (

1109 [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

1110 ) |

1111 # arrow function possible to detect only with => on same line

1112 (

1113 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

1114 $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

1115 (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

1116 \s*=> # arrow operator

1117 )

1118 ))

1119 ))

1120 captures:

1121 1: punctuation.accessor.ts

1122 2: punctuation.accessor.optional.ts

1123 3: entity.name.function.ts

1124 - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])'

1125 captures:

1126 1: punctuation.accessor.ts

1127 2: punctuation.accessor.optional.ts

1128 3: variable.other.constant.property.ts

1129 - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*([_$[:alpha:]][_$[:alnum:]]*)'

1130 captures:

1131 1: punctuation.accessor.ts

1132 2: punctuation.accessor.optional.ts

1133 3: variable.other.property.ts

1134 - match: "([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])"

1135 scope: variable.other.constant.ts

1136 - match: "[_$[:alpha:]][_$[:alnum:]]*"

1137 scope: variable.other.readwrite.ts

1138 import-declaration:

1139 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(import)(?!\s*[:\(])(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

1140 captures:

1141 1: keyword.control.export.ts

1142 2: keyword.control.import.ts

1143 push:

1144 - meta_scope: meta.import.ts

1145 - match: '(?<!^import|[^\._$[:alnum:]]import)(?=;|$|^)'

1146 pop: true

1147 - include: comment

1148 - include: string

1149 - match: '(?<=^import|[^\._$[:alnum:]]import)(?!\s*["''])'

1150 push:

1151 - match: \bfrom\b

1152 captures:

1153 0: keyword.control.from.ts

1154 pop: true

1155 - include: import-export-declaration

1156 - include: import-export-declaration

1157 import-equals-declaration:

1158 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(require)\s*(\()'

1159 captures:

1160 1: keyword.control.export.ts

1161 2: keyword.control.import.ts

1162 3: variable.other.readwrite.alias.ts

1163 4: keyword.operator.assignment.ts

1164 5: keyword.control.require.ts

1165 6: meta.brace.round.ts

1166 push:

1167 - meta_scope: meta.import-equals.external.ts

1168 - match: \)

1169 captures:

1170 0: meta.brace.round.ts

1171 pop: true

1172 - include: comment

1173 - include: string

1174 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(?!require\b)'

1175 captures:

1176 1: keyword.control.export.ts

1177 2: keyword.control.import.ts

1178 3: variable.other.readwrite.alias.ts

1179 4: keyword.operator.assignment.ts

1180 push:

1181 - meta_scope: meta.import-equals.internal.ts

1182 - match: (?=;|$|^)

1183 pop: true

1184 - include: comment

1185 - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))'

1186 captures:

1187 1: entity.name.type.module.ts

1188 2: punctuation.accessor.ts

1189 3: punctuation.accessor.optional.ts

1190 - match: "([_$[:alpha:]][_$[:alnum:]]*)"

1191 scope: variable.other.readwrite.ts

1192 import-export-block:

1193 - match: '\{'

1194 captures:

1195 0: punctuation.definition.block.ts

1196 push:

1197 - meta_scope: meta.block.ts

1198 - match: '\}'

1199 captures:

1200 0: punctuation.definition.block.ts

1201 pop: true

1202 - include: import-export-clause

1203 import-export-clause:

1204 - include: comment

1206 captures:

1207 1: keyword.control.default.ts

1208 2: constant.language.import-export-all.ts

1209 3: variable.other.readwrite.ts

1210 4: keyword.control.as.ts

1211 5: keyword.control.default.ts

1212 6: variable.other.readwrite.alias.ts

1213 - include: punctuation-comma

1214 - match: \*

1215 scope: constant.language.import-export-all.ts

1216 - match: \b(default)\b

1217 scope: keyword.control.default.ts

1218 - match: "([_$[:alpha:]][_$[:alnum:]]*)"

1219 scope: variable.other.readwrite.alias.ts

1220 import-export-declaration:

1221 - include: comment

1222 - include: string

1223 - include: import-export-block

1224 - match: \bfrom\b

1225 scope: keyword.control.from.ts

1226 - include: import-export-clause

1227 indexer-declaration:

1228 - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s*)?\s*(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s*(?=:)'

1229 captures:

1230 1: storage.modifier.ts

1231 2: meta.brace.square.ts

1232 3: variable.parameter.ts

1233 push:

1234 - meta_scope: meta.indexer.declaration.ts

1235 - match: '(\])\s*(\?\s*)?|$'

1236 captures:

1237 1: meta.brace.square.ts

1238 2: keyword.operator.optional.ts

1239 pop: true

1240 - include: type-annotation

1241 indexer-mapped-type-declaration:

1242 - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))([+-])?(readonly)\s*)?\s*(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s+(in)\s+'

1243 captures:

1244 1: keyword.operator.type.modifier.ts

1245 2: storage.modifier.ts

1246 3: meta.brace.square.ts

1247 4: entity.name.type.ts

1248 5: keyword.operator.expression.in.ts

1249 push:

1250 - meta_scope: meta.indexer.mappedtype.declaration.ts

1251 - match: '(\])([+-])?\s*(\?\s*)?|$'

1252 captures:

1253 1: meta.brace.square.ts

1254 2: keyword.operator.type.modifier.ts

1255 3: keyword.operator.optional.ts

1256 pop: true

1257 - include: type

1258 inline-tags:

1259 - match: '(\[)[^\]]+(\])(?={@(?:link|linkcode|linkplain|tutorial))'

1260 scope: constant.other.description.jsdoc

1261 captures:

1262 1: punctuation.definition.bracket.square.begin.jsdoc

1263 2: punctuation.definition.bracket.square.end.jsdoc

1264 - match: '({)((@)(?:link(?:code|plain)?|tutorial))\s*'

1265 captures:

1266 1: punctuation.definition.bracket.curly.begin.jsdoc

1267 2: storage.type.class.jsdoc

1268 3: punctuation.definition.inline.tag.jsdoc

1269 push:

1270 - meta_scope: entity.name.type.instance.jsdoc

1271 - match: '}|(?=\*/)'

1272 captures:

1273 0: punctuation.definition.bracket.curly.end.jsdoc

1274 pop: true

1275 - match: '\G((?=https?://)(?:[^|}\s*]|\*[/])+)(\|)?'

1276 captures:

1277 1: variable.other.link.underline.jsdoc

1278 2: punctuation.separator.pipe.jsdoc

1279 - match: '\G((?:[^{}@\s|*]|\*[^/])+)(\|)?'

1280 captures:

1281 1: variable.other.description.jsdoc

1282 2: punctuation.separator.pipe.jsdoc

1283 instanceof-expr:

1284 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(instanceof)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

1285 captures:

1286 1: keyword.operator.expression.instanceof.ts

1287 push:

1288 - match: '(?<=\))|(?=[;),}\]:?]|\|\||\&\&|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(]))))'

1289 pop: true

1290 - include: type

1291 interface-declaration:

1292 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(export)\s+)?\b(?:(abstract)\s+)?\b(interface)\b(?=\s+|/[/*])'

1293 captures:

1294 1: keyword.control.export.ts

1295 2: storage.modifier.ts

1296 3: storage.type.interface.ts

1297 push:

1298 - meta_scope: meta.interface.ts

1299 - match: '(?<=\})'

1300 pop: true

1301 - include: comment

1302 - include: class-or-interface-heritage

1303 - match: "[_$[:alpha:]][_$[:alnum:]]*"

1304 captures:

1305 0: entity.name.type.interface.ts

1306 - include: type-parameters

1307 - include: class-or-interface-body

1308 jsdoctype:

1309 - match: '\G{(?:[^}*]|\*[^/}])+$'

1310 scope: invalid.illegal.type.jsdoc

1311 - match: '\G({)'

1312 captures:

1313 0: entity.name.type.instance.jsdoc

1314 1: punctuation.definition.bracket.curly.begin.jsdoc

1315 push:

1316 - meta_content_scope: entity.name.type.instance.jsdoc

1317 - match: '((}))\s*|(?=\*/)'

1318 captures:

1319 1: entity.name.type.instance.jsdoc

1320 2: punctuation.definition.bracket.curly.end.jsdoc

1321 pop: true

1322 - include: brackets

1323 label:

1324 - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(:)(?=\s*\{)'

1325 captures:

1326 1: entity.name.label.ts

1327 2: punctuation.separator.label.ts

1328 push:

1329 - match: '(?<=\})'

1330 pop: true

1331 - include: decl-block

1332 - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(:)'

1333 captures:

1334 1: entity.name.label.ts

1335 2: punctuation.separator.label.ts

1336 literal:

1337 - include: numeric-literal

1338 - include: boolean-literal

1339 - include: null-literal

1340 - include: undefined-literal

1341 - include: numericConstant-literal

1342 - include: array-literal

1343 - include: this-literal

1344 - include: super-literal

1345 method-declaration:

1346 - match: '(?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?\s*\b(constructor)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

1347 captures:

1348 1: storage.modifier.ts

1349 2: storage.modifier.ts

1350 3: storage.modifier.async.ts

1351 4: storage.type.ts

1352 push:

1353 - meta_scope: meta.method.declaration.ts

1354 - match: '(?=\}|;|,|$)|(?<=\})'

1355 pop: true

1356 - include: method-declaration-name

1357 - include: function-body

1359 captures:

1360 1: storage.modifier.ts

1361 2: storage.modifier.ts

1362 3: storage.modifier.async.ts

1363 4: keyword.operator.new.ts

1364 5: keyword.generator.asterisk.ts

1365 push:

1366 - meta_scope: meta.method.declaration.ts

1367 - match: '(?=\}|;|,|$)|(?<=\})'

1368 pop: true

1369 - include: method-declaration-name

1370 - include: function-body

1371 - match: |-

1372 (?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(?!\$))|((?<!\$)(?:

1373 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1374 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1375 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1376 (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1377 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1378 (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1379 (?:\B(\.)[0-9][0-9_]*\b)| # .1

1380 (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1381 )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*[\(\<])

1382 captures:

1383 1: storage.modifier.ts

1384 2: storage.modifier.ts

1385 3: storage.modifier.async.ts

1386 4: storage.type.property.ts

1387 5: keyword.generator.asterisk.ts

1388 push:

1389 - meta_scope: meta.method.declaration.ts

1390 - match: '(?=\}|;|,|$)|(?<=\})'

1391 pop: true

1392 - include: method-declaration-name

1393 - include: function-body

1394 method-declaration-name:

1395 - match: |-

1396 (?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(?!\$))|((?<!\$)(?:

1397 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1398 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1399 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1400 (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1401 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1402 (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1403 (?:\B(\.)[0-9][0-9_]*\b)| # .1

1404 (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1405 )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??)\s*[\(\<])

1406 push:

1407 - match: (?=\(|\<)

1408 pop: true

1409 - include: string

1410 - include: array-literal

1411 - include: numeric-literal

1412 - match: "[_$[:alpha:]][_$[:alnum:]]*"

1413 scope: meta.definition.method.ts entity.name.function.ts

1414 - match: \?

1415 scope: keyword.operator.optional.ts

1416 namespace-declaration:

1417 - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(namespace|module)\s+(?=[_$[:alpha:]"''`]))'

1418 captures:

1419 1: keyword.control.export.ts

1420 2: storage.type.namespace.ts

1421 push:

1422 - meta_scope: meta.namespace.declaration.ts

1423 - 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)'

1424 pop: true

1425 - include: comment

1426 - include: string

1427 - match: "([_$[:alpha:]][_$[:alnum:]]*)"

1428 scope: entity.name.type.module.ts

1429 - include: punctuation-accessor

1430 - include: decl-block

1431 new-expr:

1432 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

1433 captures:

1434 1: keyword.operator.new.ts

1435 push:

1436 - meta_scope: new.expr.ts

1437 - match: '(?<=\))|(?=[;),}\]:]|\|\||\&\&|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(]))))'

1438 pop: true

1439 - include: paren-expression

1440 - include: class-declaration

1441 - include: type

1442 null-literal:

1443 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))null(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

1444 scope: constant.language.null.ts

1445 numeric-literal:

1446 - match: '\b(?<!\$)0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\b(?!\$)'

1447 scope: constant.numeric.hex.ts

1448 - match: '\b(?<!\$)0(b|B)[01][01_]*\b(?!\$)'

1449 scope: constant.numeric.binary.ts

1450 - match: '\b(?<!\$)0(o|O)?[0-7][0-7_]*\b(?!\$)'

1451 scope: constant.numeric.octal.ts

1452 - match: |-

1453 (?x)

1454 (?<!\$)(?:

1455 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1456 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1457 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1458 (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1459 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1460 (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1461 (?:\B(\.)[0-9][0-9_]*\b)| # .1

1462 (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1463 )(?!\$)

1464 captures:

1465 0: constant.numeric.decimal.ts

1466 1: meta.delimiter.decimal.period.ts

1467 2: meta.delimiter.decimal.period.ts

1468 3: meta.delimiter.decimal.period.ts

1469 4: meta.delimiter.decimal.period.ts

1470 5: meta.delimiter.decimal.period.ts

1471 6: meta.delimiter.decimal.period.ts

1472 numericConstant-literal:

1473 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))NaN(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

1474 scope: constant.language.nan.ts

1475 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Infinity(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

1476 scope: constant.language.infinity.ts

1477 object-binding-element:

1478 - include: comment

1479 - match: |-

1480 (?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(?!\$))|((?<!\$)(?:

1481 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1482 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1483 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1484 (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1485 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1486 (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1487 (?:\B(\.)[0-9][0-9_]*\b)| # .1

1488 (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1489 )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))

1490 push:

1491 - match: '(?=,|\})'

1492 pop: true

1493 - include: object-binding-element-propertyName

1494 - include: binding-element

1495 - include: object-binding-pattern

1496 - include: destructuring-variable-rest

1497 - include: variable-initializer

1498 - include: punctuation-comma

1499 object-binding-element-const:

1500 - include: comment

1501 - match: |-

1502 (?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(?!\$))|((?<!\$)(?:

1503 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1504 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1505 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1506 (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1507 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1508 (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1509 (?:\B(\.)[0-9][0-9_]*\b)| # .1

1510 (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1511 )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))

1512 push:

1513 - match: '(?=,|\})'

1514 pop: true

1515 - include: object-binding-element-propertyName

1516 - include: binding-element-const

1517 - include: object-binding-pattern-const

1518 - include: destructuring-variable-rest-const

1519 - include: variable-initializer

1520 - include: punctuation-comma

1521 object-binding-element-propertyName:

1522 - match: |-

1523 (?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(?!\$))|((?<!\$)(?:

1524 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1525 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1526 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1527 (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1528 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1529 (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1530 (?:\B(\.)[0-9][0-9_]*\b)| # .1

1531 (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1532 )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))

1533 push:

1534 - match: (:)

1535 captures:

1536 0: punctuation.destructuring.ts

1537 pop: true

1538 - include: string

1539 - include: array-literal

1540 - include: numeric-literal

1541 - match: "([_$[:alpha:]][_$[:alnum:]]*)"

1542 scope: variable.object.property.ts

1543 object-binding-pattern:

1544 - match: '(?:(\.\.\.)\s*)?(\{)'

1545 captures:

1546 1: keyword.operator.rest.ts

1547 2: punctuation.definition.binding-pattern.object.ts

1548 push:

1549 - match: '\}'

1550 captures:

1551 0: punctuation.definition.binding-pattern.object.ts

1552 pop: true

1553 - include: object-binding-element

1554 object-binding-pattern-const:

1555 - match: '(?:(\.\.\.)\s*)?(\{)'

1556 captures:

1557 1: keyword.operator.rest.ts

1558 2: punctuation.definition.binding-pattern.object.ts

1559 push:

1560 - match: '\}'

1561 captures:

1562 0: punctuation.definition.binding-pattern.object.ts

1563 pop: true

1564 - include: object-binding-element-const

1565 object-identifiers:

1566 - match: '([_$[:alpha:]][_$[:alnum:]]*)(?=\s*\??\.\s*prototype\b(?!\$))'

1567 scope: support.class.ts

1568 - match: |-

1569 (?x)(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(?:

1570 ([[:upper:]][_$[:digit:][:upper:]]*) |

1571 ([_$[:alpha:]][_$[:alnum:]]*)

1572 )(?=\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)

1573 captures:

1574 1: punctuation.accessor.ts

1575 2: punctuation.accessor.optional.ts

1576 3: variable.other.constant.object.property.ts

1577 4: variable.other.object.property.ts

1578 - match: |-

1579 (?x)(?:

1580 ([[:upper:]][_$[:digit:][:upper:]]*) |

1581 ([_$[:alpha:]][_$[:alnum:]]*)

1582 )(?=\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)

1583 captures:

1584 1: variable.other.constant.object.ts

1585 2: variable.other.object.ts

1586 object-literal:

1587 - match: '\{'

1588 captures:

1589 0: punctuation.definition.block.ts

1590 push:

1591 - meta_scope: meta.objectliteral.ts

1592 - match: '\}'

1593 captures:

1594 0: punctuation.definition.block.ts

1595 pop: true

1596 - include: object-member

1597 object-literal-method-declaration:

1598 - match: |-

1599 (?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(?!\$))|((?<!\$)(?:

1600 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1601 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1602 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1603 (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1604 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1605 (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1606 (?:\B(\.)[0-9][0-9_]*\b)| # .1

1607 (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1608 )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*[\(\<])

1609 captures:

1610 1: storage.modifier.async.ts

1611 2: storage.type.property.ts

1612 3: keyword.generator.asterisk.ts

1613 push:

1614 - meta_scope: meta.method.declaration.ts

1615 - match: '(?=\}|;|,)|(?<=\})'

1616 pop: true

1617 - include: method-declaration-name

1618 - include: function-body

1619 - match: |-

1620 (?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(?!\$))|((?<!\$)(?:

1621 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1622 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1623 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1624 (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1625 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1626 (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1627 (?:\B(\.)[0-9][0-9_]*\b)| # .1

1628 (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1629 )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*[\(\<])

1630 captures:

1631 1: storage.modifier.async.ts

1632 2: storage.type.property.ts

1633 3: keyword.generator.asterisk.ts

1634 push:

1635 - match: (?=\(|\<)

1636 pop: true

1637 - include: method-declaration-name

1638 object-member:

1639 - include: comment

1640 - include: object-literal-method-declaration

1641 - match: '(?=\[)'

1642 push:

1643 - meta_scope: meta.object.member.ts meta.object-literal.key.ts

1644 - match: '(?=:)|((?<=[\]])(?=\s*[\(\<]))'

1645 pop: true

1646 - include: array-literal

1647 - match: '(?=[\''\"])'

1648 push:

1649 - meta_scope: meta.object.member.ts meta.object-literal.key.ts

1650 - match: '(?=:)|((?<=[\''\"])(?=\s*[\(\<]))'

1651 pop: true

1652 - include: string

1653 - match: '(?<=[\]\''\"])(?=\s*[\(\<])'

1654 push:

1655 - meta_scope: meta.method.declaration.ts

1656 - match: '(?=\}|;|,)|(?<=\})'

1657 pop: true

1658 - include: function-body

1659 - match: '(?![_$[:alpha:]])([[:digit:]]+)\s*(?=:)'

1660 scope: meta.object.member.ts

1661 captures:

1662 0: meta.object-literal.key.ts

1663 1: constant.numeric.decimal.ts

1664 - match: |-

1665 (?x)(?:([_$[:alpha:]][_$[:alnum:]]*)\s*(?=:\s*(

1666 ((async\s+)?(

1667 (function\s*[(<*]) |

1668 (function\s+) |

1669 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

1670 )) |

1671 ((async\s*)?(

1672 ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$)) |

1673 # sure shot arrow functions even if => is on new line

1674 (

1675 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

1676 [(]\s*

1677 (

1678 ([)]\s*:) | # ():

1679 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

1680 )

1681 ) |

1682 (

1683 [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

1684 ) |

1685 # arrow function possible to detect only with => on same line

1686 (

1687 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

1688 $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

1689 (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

1690 \s*=> # arrow operator

1691 )

1692 ))

1693 )))

1694 scope: meta.object.member.ts

1695 captures:

1696 0: meta.object-literal.key.ts

1697 1: entity.name.function.ts

1698 - match: '(?:[_$[:alpha:]][_$[:alnum:]]*)\s*(?=:)'

1699 scope: meta.object.member.ts

1700 captures:

1701 0: meta.object-literal.key.ts

1702 - match: \.\.\.

1703 captures:

1704 0: keyword.operator.spread.ts

1705 push:

1706 - meta_scope: meta.object.member.ts

1707 - match: '(?=,|\})'

1708 pop: true

1709 - include: expression

1710 - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?=,|\}|$)'

1711 scope: meta.object.member.ts

1712 captures:

1713 1: variable.other.readwrite.ts

1714 - match: '(?=[_$[:alpha:]][_$[:alnum:]]*\s*=)'

1715 push:

1716 - meta_scope: meta.object.member.ts

1717 - match: '(?=,|\}|$)'

1718 pop: true

1719 - include: expression

1720 - match: ":"

1721 captures:

1722 0: meta.object-literal.key.ts punctuation.separator.key-value.ts

1723 push:

1724 - meta_scope: meta.object.member.ts

1725 - match: '(?=,|\})'

1726 pop: true

1727 - match: '(?<=:)\s*(async)?(?=\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)\(\s*([\{\[]\s*)?$)'

1728 captures:

1729 1: storage.modifier.async.ts

1730 push:

1731 - match: (?<=\))

1732 pop: true

1733 - include: type-parameters

1734 - match: \(

1735 captures:

1736 0: meta.brace.round.ts

1737 push:

1738 - match: \)

1739 captures:

1740 0: meta.brace.round.ts

1741 pop: true

1742 - include: expression-inside-possibly-arrow-parens

1743 - match: '(?<=:)\s*(async)?\s*(\()(?=\s*([\{\[]\s*)?$)'

1744 captures:

1745 1: storage.modifier.async.ts

1746 2: meta.brace.round.ts

1747 push:

1748 - match: \)

1749 captures:

1750 0: meta.brace.round.ts

1751 pop: true

1752 - include: expression-inside-possibly-arrow-parens

1753 - include: expression

1754 - include: punctuation-comma

1755 parameter-array-binding-pattern:

1756 - match: '(?:(\.\.\.)\s*)?(\[)'

1757 captures:

1758 1: keyword.operator.rest.ts

1759 2: punctuation.definition.binding-pattern.array.ts

1760 push:

1761 - match: '\]'

1762 captures:

1763 0: punctuation.definition.binding-pattern.array.ts

1764 pop: true

1765 - include: parameter-binding-element

1766 - include: punctuation-comma

1767 parameter-binding-element:

1768 - include: comment

1769 - include: string

1770 - include: parameter-object-binding-pattern

1771 - include: parameter-array-binding-pattern

1772 - include: destructuring-parameter-rest

1773 - include: variable-initializer

1774 parameter-name:

1776 captures:

1777 1: storage.modifier.ts

1778 - match: |-

1780 # function assignment |

1781 (=\s*(

1782 ((async\s+)?(

1783 (function\s*[(<*]) |

1784 (function\s+) |

1785 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

1786 )) |

1787 ((async\s*)?(

1788 ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$)) |

1789 # sure shot arrow functions even if => is on new line

1790 (

1791 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

1792 [(]\s*

1793 (

1794 ([)]\s*:) | # ():

1795 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

1796 )

1797 ) |

1798 (

1799 [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

1800 ) |

1801 # arrow function possible to detect only with => on same line

1802 (

1803 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

1804 $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

1805 (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

1806 \s*=> # arrow operator

1807 )

1808 ))

1809 )) |

1811 (:\s*(

1812 (<) |

1813 ([(]\s*(

1814 ([)]) |

1815 (\.\.\.) |

1816 ([_$[:alnum:]]+\s*(

1817 ([:,?=])|

1818 ([)]\s*=>)

1819 ))

1820 ))

1821 )) |

1822 (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$))) |

1823 (:\s*(=>|($([^\($]|($[^\($]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

1824 ((async\s+)?(

1825 (function\s*[(<*]) |

1826 (function\s+) |

1827 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

1828 )) |

1829 ((async\s*)?(

1830 ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$)) |

1831 # sure shot arrow functions even if => is on new line

1832 (

1833 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

1834 [(]\s*

1835 (

1836 ([)]\s*:) | # ():

1837 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

1838 )

1839 ) |

1840 (

1841 [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

1842 ) |

1843 # arrow function possible to detect only with => on same line

1844 (

1845 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

1846 $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

1847 (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

1848 \s*=> # arrow operator

1849 )

1850 ))

1851 )))

1852 captures:

1853 1: storage.modifier.ts

1854 2: keyword.operator.rest.ts

1855 3: entity.name.function.ts variable.language.this.ts

1856 4: entity.name.function.ts

1857 5: keyword.operator.optional.ts

1859 captures:

1860 1: storage.modifier.ts

1861 2: keyword.operator.rest.ts

1862 3: variable.parameter.ts variable.language.this.ts

1863 4: variable.parameter.ts

1864 5: keyword.operator.optional.ts

1865 parameter-object-binding-element:

1866 - include: comment

1867 - match: |-

1868 (?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(?!\$))|((?<!\$)(?:

1869 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1.1E+3

1870 (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*\b)| # 1.E+3

1871 (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # .1E+3

1872 (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*\b)| # 1E+3

1873 (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*\b)| # 1.1

1874 (?:\b[0-9][0-9_]*(\.)\B)| # 1.

1875 (?:\B(\.)[0-9][0-9_]*\b)| # .1

1876 (?:\b[0-9][0-9_]*\b(?!\.)) # 1

1877 )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\\'|\\)*\')|(\"([^\"\\]|\\\"|\\)*\")|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))

1878 push:

1879 - match: '(?=,|\})'

1880 pop: true

1881 - include: object-binding-element-propertyName

1882 - include: parameter-binding-element

1883 - include: parameter-object-binding-pattern

1884 - include: destructuring-parameter-rest

1885 - include: variable-initializer

1886 - include: punctuation-comma

1887 parameter-object-binding-pattern:

1888 - match: '(?:(\.\.\.)\s*)?(\{)'

1889 captures:

1890 1: keyword.operator.rest.ts

1891 2: punctuation.definition.binding-pattern.object.ts

1892 push:

1893 - match: '\}'

1894 captures:

1895 0: punctuation.definition.binding-pattern.object.ts

1896 pop: true

1897 - include: parameter-object-binding-element

1898 paren-expression:

1899 - match: \(

1900 captures:

1901 0: meta.brace.round.ts

1902 push:

1903 - match: \)

1904 captures:

1905 0: meta.brace.round.ts

1906 pop: true

1907 - include: expression

1908 paren-expression-possibly-arrow:

1909 - match: '(?<=[(=,])\s*(async)?(?=\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*))?\(\s*[\{\[]\s*$)'

1910 captures:

1911 1: storage.modifier.async.ts

1912 push:

1913 - match: (?<=\))

1914 pop: true

1915 - include: paren-expression-possibly-arrow-with-typeparameters

1916 - match: '(?<=[(=,]|=>)\s*(async)?(?=\s*((((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*))?\()|(<))\s*$)'

1917 captures:

1918 1: storage.modifier.async.ts

1919 push:

1920 - match: (?<=\))

1921 pop: true

1922 - include: paren-expression-possibly-arrow-with-typeparameters

1923 - include: possibly-arrow-return-type

1924 paren-expression-possibly-arrow-with-typeparameters:

1925 - include: type-parameters

1926 - match: \(

1927 captures:

1928 0: meta.brace.round.ts

1929 push:

1930 - match: \)

1931 captures:

1932 0: meta.brace.round.ts

1933 pop: true

1934 - include: expression-inside-possibly-arrow-parens

1935 possibly-arrow-return-type:

1936 - match: '(?<=\))\s*(:)(?=\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+\s*=>)'

1937 captures:

1938 1: meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts

1939 push:

1940 - meta_content_scope: meta.arrow.ts meta.return.type.arrow.ts

1941 - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))'

1942 pop: true

1943 - include: arrow-return-type-body

1944 property-accessor:

1945 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(get|set)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

1946 scope: storage.type.property.ts

1947 punctuation-accessor:

1948 - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))'

1949 captures:

1950 1: punctuation.accessor.ts

1951 2: punctuation.accessor.optional.ts

1952 punctuation-comma:

1953 - match: ","

1954 scope: punctuation.separator.comma.ts

1955 punctuation-semicolon:

1956 - match: ;

1957 scope: punctuation.terminator.statement.ts

1958 qstring-double:

1959 - match: '"'

1960 captures:

1961 0: punctuation.definition.string.begin.ts

1962 push:

1963 - meta_scope: string.quoted.double.ts

1964 - match: '(")|((?:[^\\\n])$)'

1965 captures:

1966 1: punctuation.definition.string.end.ts

1967 2: invalid.illegal.newline.ts

1968 pop: true

1969 - include: string-character-escape

1970 qstring-single:

1971 - match: "'"

1972 captures:

1973 0: punctuation.definition.string.begin.ts

1974 push:

1975 - meta_scope: string.quoted.single.ts

1976 - match: '(\'')|((?:[^\\\n])$)'

1977 captures:

1978 1: punctuation.definition.string.end.ts

1979 2: invalid.illegal.newline.ts

1980 pop: true

1981 - include: string-character-escape

1982 regex:

1983 - match: '(?<!\+\+|--|})(?<=[=(:,\[?+!]|^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/[gimsuy]*(?!\s*[a-zA-Z0-9_$]))'

1984 captures:

1985 1: punctuation.definition.string.begin.ts

1986 push:

1987 - meta_scope: string.regexp.ts

1988 - match: "(/)([gimsuy]*)"

1989 captures:

1990 1: punctuation.definition.string.end.ts

1991 2: keyword.other.ts

1992 pop: true

1993 - include: regexp

1994 - match: '(?<![_$[:alnum:])\]]|\+\+|--|})\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)+\])+\/[gimsuy]*(?!\s*[a-zA-Z0-9_$]))'

1995 captures:

1996 0: punctuation.definition.string.begin.ts

1997 push:

1998 - meta_scope: string.regexp.ts

1999 - match: "(/)([gimsuy]*)"

2000 captures:

2001 1: punctuation.definition.string.end.ts

2002 2: keyword.other.ts

2003 pop: true

2004 - include: regexp

2005 regex-character-class:

2006 - match: '\\[wWsSdDtrnvf]|\.'

2007 scope: constant.other.character-class.regexp

2008 - match: '\\([0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4})'

2009 scope: constant.character.numeric.regexp

2010 - match: '\\c[A-Z]'

2011 scope: constant.character.control.regexp

2012 - match: \\.

2013 scope: constant.character.escape.backslash.regexp

2014 regexp:

2015 - match: '\\[bB]|\^|\$'

2016 scope: keyword.control.anchor.regexp

2017 - match: '\\[1-9]\d*|\\k<([a-zA-Z_$][\w$]*)>'

2018 captures:

2019 0: keyword.other.back-reference.regexp

2020 1: variable.other.regexp

2021 - match: '[?+*]|\{(\d+,\d+|\d+,|,\d+|\d+)\}\??'

2022 scope: keyword.operator.quantifier.regexp

2023 - match: \|

2024 scope: keyword.operator.or.regexp

2025 - match: (\()((\?=)|(\?!)|(\?<=)|(\?<!))

2026 captures:

2027 1: punctuation.definition.group.regexp

2028 2: punctuation.definition.group.assertion.regexp

2029 3: meta.assertion.look-ahead.regexp

2030 4: meta.assertion.negative-look-ahead.regexp

2031 5: meta.assertion.look-behind.regexp

2032 6: meta.assertion.negative-look-behind.regexp

2033 push:

2034 - meta_scope: meta.group.assertion.regexp

2035 - match: (\))

2036 captures:

2037 1: punctuation.definition.group.regexp

2038 pop: true

2039 - include: regexp

2040 - match: '\((?:(\?:)|(?:\?<([a-zA-Z_$][\w$]*)>))?'

2041 captures:

2042 0: punctuation.definition.group.regexp

2043 1: punctuation.definition.group.no-capture.regexp

2044 2: variable.other.regexp

2045 push:

2046 - meta_scope: meta.group.regexp

2047 - match: \)

2048 captures:

2049 0: punctuation.definition.group.regexp

2050 pop: true

2051 - include: regexp

2052 - match: '(\[)(\^)?'

2053 captures:

2054 1: punctuation.definition.character-class.regexp

2055 2: keyword.operator.negation.regexp

2056 push:

2057 - meta_scope: constant.other.character-class.set.regexp

2058 - match: '(\])'

2059 captures:

2060 1: punctuation.definition.character-class.regexp

2061 pop: true

2062 - match: '(?:.|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.))\-(?:[^\]\\]|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.))'

2063 scope: constant.other.character-class.range.regexp

2064 captures:

2065 1: constant.character.numeric.regexp

2066 2: constant.character.control.regexp

2067 3: constant.character.escape.backslash.regexp

2068 4: constant.character.numeric.regexp

2069 5: constant.character.control.regexp

2070 6: constant.character.escape.backslash.regexp

2071 - include: regex-character-class

2072 - include: regex-character-class

2073 return-type:

2074 - match: (?<=\))\s*(:)(?=\s*\S)

2075 captures:

2076 1: keyword.operator.type.annotation.ts

2077 push:

2078 - meta_scope: meta.return.type.ts

2079 - match: "(?<![:|&])(?=$|^|[{};,]|//)"

2080 pop: true

2081 - include: return-type-core

2082 - match: (?<=\))\s*(:)

2083 captures:

2084 1: keyword.operator.type.annotation.ts

2085 push:

2086 - meta_scope: meta.return.type.ts

2087 - match: '(?<![:|&])((?=[{};,]|//|^\s*$)|((?<=\S)(?=\s*$)))'

2088 pop: true

2089 - include: return-type-core

2090 return-type-core:

2091 - include: comment

2092 - match: '(?<=[:|&])(?=\s*\{)'

2093 push:

2094 - match: '(?<=\})'

2095 pop: true

2096 - include: type-object

2097 - include: type-predicate-operator

2098 - include: type

2099 statements:

2100 - include: string

2101 - include: template

2102 - include: comment

2103 - include: declaration

2104 - include: control-statement

2105 - include: after-operator-block-as-object-literal

2106 - include: decl-block

2107 - include: label

2108 - include: expression

2109 - include: punctuation-semicolon

2110 string:

2111 - include: qstring-single

2112 - include: qstring-double

2113 string-character-escape:

2114 - 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]?|.|$)'

2115 scope: constant.character.escape.ts

2116 super-literal:

2117 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))super\b(?!\$)'

2118 scope: variable.language.super.ts

2119 support-objects:

2120 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(arguments)\b(?!\$)'

2121 scope: variable.language.arguments.ts

2122 - match: |-

2127 scope: support.class.builtin.ts

2129 scope: support.class.error.ts

2130 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Promise)\b(?!\$)'

2131 scope: support.class.promise.ts

2132 - match: |-

2135 scope: support.function.ts

2136 - match: |-

2137 (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Math)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(?:

2139 expm1|floor|fround|hypot|imul|log|log10|log1p|log2|max|min|pow|random|

2141 |

2142 (E|LN10|LN2|LOG10E|LOG2E|PI|SQRT1_2|SQRT2)))?\b(?!\$)

2143 captures:

2144 1: support.constant.math.ts

2145 2: punctuation.accessor.ts

2146 3: punctuation.accessor.optional.ts

2147 4: support.function.math.ts

2148 5: support.constant.property.math.ts

2149 - match: |-

2150 (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(console)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(

2153 captures:

2154 1: support.class.console.ts

2155 2: punctuation.accessor.ts

2156 3: punctuation.accessor.optional.ts

2157 4: support.function.console.ts

2158 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(JSON)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(parse|stringify))?\b(?!\$)'

2159 captures:

2160 1: support.constant.json.ts

2161 2: punctuation.accessor.ts

2162 3: punctuation.accessor.optional.ts

2163 4: support.function.json.ts

2164 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(import)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(meta)\b(?!\$)'

2165 captures:

2166 1: keyword.control.import.ts

2167 2: punctuation.accessor.ts

2168 3: punctuation.accessor.optional.ts

2169 4: support.variable.property.importmeta.ts

2170 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(target)\b(?!\$)'

2171 captures:

2172 1: keyword.operator.new.ts

2173 2: punctuation.accessor.ts

2174 3: punctuation.accessor.optional.ts

2175 4: support.variable.property.target.ts

2176 - match: |-

2177 (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?:

2178 (constructor|length|prototype|__proto__)

2179 |

2181 captures:

2182 1: punctuation.accessor.ts

2183 2: punctuation.accessor.optional.ts

2184 3: support.variable.property.ts

2185 4: support.constant.ts

2186 - match: |-

2187 (?x) (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.)) \b (?:

2189 |

2248 |XSLTProcessor))\b(?!\$)

2249 captures:

2250 1: support.variable.dom.ts

2251 2: support.class.dom.ts

2252 - match: |-

2253 (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?:

2258 |

2284 |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?\()

2285 captures:

2286 1: punctuation.accessor.ts

2287 2: punctuation.accessor.optional.ts

2288 3: support.constant.dom.ts

2289 4: support.variable.property.dom.ts

2290 - match: |-

2293 scope: support.class.node.ts

2294 - match: |-

2295 (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(process)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))(?:

2297 |

2299 ))?\b(?!\$)

2300 captures:

2301 1: support.variable.object.process.ts

2302 2: punctuation.accessor.ts

2303 3: punctuation.accessor.optional.ts

2304 4: support.variable.property.process.ts

2305 5: support.function.process.ts

2307 captures:

2308 1: support.type.object.module.ts

2309 2: support.type.object.module.ts

2310 3: punctuation.accessor.ts

2311 4: punctuation.accessor.optional.ts

2312 5: support.type.object.module.ts

2314 scope: support.variable.object.node.ts

2315 - match: |-

2316 (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s*

2317 (?:

2326 ) |

2345 ) |

2350 compareBoundaryPoints|compareDocumentPosition|comparePoint|contains|

2351 convertPointFromNode|convertQuadFromNode|convertRectFromNode|createAttribute|

2352 createAttributeNS|createCaption|createCDATASection|createComment|

2353 createContextualFragment|createDocument|createDocumentFragment|

2354 createDocumentType|createElement|createElementNS|createEntityReference|

2355 createEvent|createExpression|createHTMLDocument|createNodeIterator|

2356 createNSResolver|createProcessingInstruction|createRange|createShadowRoot|

2363 getAttributeNodeNS|getAttributeNS|getBoundingClientRect|getBoxQuads|

2364 getClientRects|getContext|getDestinationInsertionPoints|getElementById|

2365 getElementsByClassName|getElementsByName|getElementsByTagName|

2375 previousSibling|probablySupportsContext|queryCommandEnabled|

2376 queryCommandIndeterm|queryCommandState|queryCommandSupported|queryCommandValue|

2377 querySelector|querySelectorAll|registerContentHandler|registerElement|

2379 removeAttributeNode|removeAttributeNS|removeChild|removeEventListener|

2383 setAttributeNode|setAttributeNodeNS|setAttributeNS|setCapture|

2389 ) |

2391 )

2392 )(?=\s*\()

2393 captures:

2394 1: punctuation.accessor.ts

2395 2: punctuation.accessor.optional.ts

2396 3: support.function.event-handler.ts

2397 4: support.function.ts

2398 5: support.function.dom.ts

2399 6: support.function.promise.ts

2400 switch-statement:

2401 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bswitch\s*\()'

2402 push:

2403 - meta_scope: switch-statement.expr.ts

2404 - match: '\}'

2405 captures:

2406 0: punctuation.definition.block.ts

2407 pop: true

2408 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(switch)\s*(\()'

2409 captures:

2410 1: keyword.control.switch.ts

2411 2: meta.brace.round.ts

2412 push:

2413 - meta_scope: switch-expression.expr.ts

2414 - match: \)

2415 captures:

2416 0: meta.brace.round.ts

2417 pop: true

2418 - include: expression

2419 - match: '\{'

2420 captures:

2421 0: punctuation.definition.block.ts

2422 push:

2423 - meta_scope: switch-block.expr.ts

2424 - match: '(?=\})'

2425 pop: true

2426 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default(?=:))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

2427 captures:

2428 1: keyword.control.switch.ts

2429 push:

2430 - meta_scope: case-clause.expr.ts

2431 - match: (?=:)

2432 pop: true

2433 - include: expression

2434 - match: '(:)\s*(\{)'

2435 captures:

2436 1: case-clause.expr.ts punctuation.definition.section.case-statement.ts

2437 2: meta.block.ts punctuation.definition.block.ts

2438 push:

2439 - meta_content_scope: meta.block.ts

2440 - match: '\}'

2441 captures:

2442 0: meta.block.ts punctuation.definition.block.ts

2443 pop: true

2444 - include: statements

2445 - match: (:)

2446 captures:

2447 0: case-clause.expr.ts punctuation.definition.section.case-statement.ts

2448 - include: statements

2449 template:

2450 - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?=(<\s*(((keyof|infer)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))(?=\s*([\<\>\,\.\[=]|&(?!&)|\|(?!\|)))))([^<>$]|(\(([^\($]|($[^\($]*\)))*\))|(?<==)\>|\<\s*(((keyof|infer)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\''[^\'']*\'')|(\"[^\"]*\")|(\`[^\`]*\`))(?=\s*([\<\>\,\.\[=]|&(?!&)|\|(?!\|)))))([^<>$]|(\(([^\($]|($[^\($]*\)))*\))|(?<==)\>)*(?!=)\>)*(?!=)>\s*)`)'

2451 captures:

2452 1: entity.name.function.tagged-template.ts

2453 push:

2454 - meta_scope: string.template.ts

2455 - match: (?=`)

2456 pop: true

2457 - include: type-arguments

2458 - match: "([_$[:alpha:]][_$[:alnum:]]*)?(`)"

2459 captures:

2460 1: entity.name.function.tagged-template.ts

2461 2: punctuation.definition.string.template.begin.ts

2462 push:

2463 - meta_scope: string.template.ts

2464 - match: "`"

2465 captures:

2466 0: punctuation.definition.string.template.end.ts

2467 pop: true

2468 - include: template-substitution-element

2469 - include: string-character-escape

2470 template-substitution-element:

2471 - match: '\$\{'

2472 captures:

2473 0: punctuation.definition.template-expression.begin.ts

2474 push:

2475 - meta_scope: meta.template.expression.ts

2476 - meta_content_scope: meta.embedded.line.ts

2477 - match: '\}'

2478 captures:

2479 0: punctuation.definition.template-expression.end.ts

2480 pop: true

2481 - include: expression

2482 ternary-expression:

2483 - match: '(?!\?\.\s*[^[:digit:]])(\?)'

2484 captures:

2485 1: keyword.operator.ternary.ts

2486 push:

2487 - match: \s*(:)

2488 captures:

2489 1: keyword.operator.ternary.ts

2490 pop: true

2491 - include: expression

2492 this-literal:

2493 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))this\b(?!\$)'

2494 scope: variable.language.this.ts

2495 type:

2496 - include: comment

2497 - include: string

2498 - include: numeric-literal

2499 - include: type-primitive

2500 - include: type-builtin-literals

2501 - include: type-parameters

2502 - include: type-tuple

2503 - include: type-object

2504 - include: type-conditional

2505 - include: type-operators

2506 - include: type-fn-type-parameters

2507 - include: type-paren-or-function-parameters

2508 - include: type-function-return-type

2509 - include: type-name

2510 type-alias-declaration:

2511 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(type)\b\s+([_$[:alpha:]][_$[:alnum:]]*)\s*'

2512 captures:

2513 1: keyword.control.export.ts

2514 2: storage.type.type.ts

2515 3: entity.name.type.alias.ts

2516 push:

2517 - meta_scope: meta.type.declaration.ts

2518 - 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)'

2519 pop: true

2520 - include: comment

2521 - include: type-parameters

2522 - match: (=)\s*

2523 captures:

2524 1: keyword.operator.assignment.ts

2525 push:

2526 - 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)'

2527 pop: true

2528 - include: type

2529 type-annotation:

2530 - match: (:)(?=\s*\S)

2531 captures:

2532 1: keyword.operator.type.annotation.ts

2533 push:

2534 - meta_scope: meta.type.annotation.ts

2535 - match: '(?<![:|&])((?=$|^|[,);\}\]]|//)|(?==[^>])|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)))'

2536 pop: true

2537 - include: type

2538 - match: (:)

2539 captures:

2540 1: keyword.operator.type.annotation.ts

2541 push:

2542 - meta_scope: meta.type.annotation.ts

2543 - match: '(?<![:|&])((?=[,);\}\]]|//)|(?==[^>])|(?=^\s*$)|((?<=\S)(?=\s*$))|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)))'

2544 pop: true

2545 - include: type

2546 type-arguments:

2547 - match: \<

2548 captures:

2549 0: punctuation.definition.typeparameters.begin.ts

2550 push:

2551 - meta_scope: meta.type.parameters.ts

2552 - match: \>

2553 captures:

2554 0: punctuation.definition.typeparameters.end.ts

2555 pop: true

2556 - include: type

2557 - include: punctuation-comma

2558 type-builtin-literals:

2560 scope: support.type.builtin.ts

2561 type-conditional:

2562 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(extends)\s+'

2563 captures:

2564 1: storage.modifier.ts

2565 push:

2566 - match: (?<=:)

2567 pop: true

2568 - match: \?

2569 captures:

2570 0: keyword.operator.ternary.ts

2571 push:

2572 - match: ":"

2573 captures:

2574 0: keyword.operator.ternary.ts

2575 pop: true

2576 - include: type

2577 - include: type

2578 type-fn-type-parameters:

2579 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\b(?=\s*\<)'

2580 scope: meta.type.constructor.ts

2581 captures:

2582 1: keyword.control.new.ts

2583 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\b\s*(?=\()'

2584 captures:

2585 1: keyword.control.new.ts

2586 push:

2587 - meta_scope: meta.type.constructor.ts

2588 - match: (?<=\))

2589 pop: true

2590 - include: function-parameters

2591 - match: |-

2592 (?x)(

2593 (?=

2594 [(]\s*(

2595 ([)]) |

2596 (\.\.\.) |

2597 ([_$[:alnum:]]+\s*(

2598 ([:,?=])|

2599 ([)]\s*=>)

2600 ))

2601 )

2602 )

2603 )

2604 push:

2605 - meta_scope: meta.type.function.ts

2606 - match: (?<=\))

2607 pop: true

2608 - include: function-parameters

2609 type-function-return-type:

2610 - match: (=>)(?=\s*\S)

2611 captures:

2612 1: storage.type.function.arrow.ts

2613 push:

2614 - meta_scope: meta.type.function.return.ts

2615 - match: '(?<!=>)(?<![|&])(?=[,\]\)\{\}=;>:\?]|//|$)'

2616 pop: true

2617 - include: type-function-return-type-core

2618 - match: "=>"

2619 captures:

2620 0: storage.type.function.arrow.ts

2621 push:

2622 - meta_scope: meta.type.function.return.ts

2623 - match: '(?<!=>)(?<![|&])((?=[,\]\)\{\}=;:\?>]|//|^\s*$)|((?<=\S)(?=\s*$)))'

2624 pop: true

2625 - include: type-function-return-type-core

2626 type-function-return-type-core:

2627 - include: comment

2628 - match: '(?<==>)(?=\s*\{)'

2629 push:

2630 - match: '(?<=\})'

2631 pop: true

2632 - include: type-object

2633 - include: type-predicate-operator

2634 - include: type

2635 type-name:

2636 - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))'

2637 captures:

2638 1: entity.name.type.module.ts

2639 2: punctuation.accessor.ts

2640 3: punctuation.accessor.optional.ts

2641 - match: "[_$[:alpha:]][_$[:alnum:]]*"

2642 scope: entity.name.type.ts

2643 type-object:

2644 - match: '\{'

2645 captures:

2646 0: punctuation.definition.block.ts

2647 push:

2648 - meta_scope: meta.object.type.ts

2649 - match: '\}'

2650 captures:

2651 0: punctuation.definition.block.ts

2652 pop: true

2653 - include: comment

2654 - include: method-declaration

2655 - include: indexer-declaration

2656 - include: indexer-mapped-type-declaration

2657 - include: field-declaration

2658 - include: type-annotation

2659 - match: \.\.\.

2660 captures:

2661 0: keyword.operator.spread.ts

2662 push:

2663 - match: '(?=\}|;|,|$)|(?<=\})'

2664 pop: true

2665 - include: type

2666 - include: punctuation-comma

2667 - include: punctuation-semicolon

2668 - include: type

2669 type-operators:

2670 - include: typeof-operator

2671 - match: '(?:([&|])|(=(?!>)))(?=\s*\{)'

2672 captures:

2673 1: keyword.operator.type.ts

2674 2: keyword.operator.assignment.ts

2675 push:

2676 - match: '(?<=\})'

2677 pop: true

2678 - include: type-object

2679 - match: "([&|])|(=(?!>))"

2680 captures:

2681 1: keyword.operator.type.ts

2682 2: keyword.operator.assignment.ts

2683 push:

2684 - match: (?=\S)

2685 pop: true

2686 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))keyof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

2687 scope: keyword.operator.expression.keyof.ts

2688 - match: (\?|\:)

2689 scope: keyword.operator.ternary.ts

2690 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))infer(?=\s+[_$[:alpha:]])'

2691 scope: keyword.operator.expression.infer.ts

2692 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*\()'

2693 scope: keyword.operator.expression.import.ts

2694 type-parameters:

2695 - match: (<)

2696 captures:

2697 1: punctuation.definition.typeparameters.begin.ts

2698 push:

2699 - meta_scope: meta.type.parameters.ts

2700 - match: (>)

2701 captures:

2702 1: punctuation.definition.typeparameters.end.ts

2703 pop: true

2704 - include: comment

2705 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(extends)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

2706 scope: storage.modifier.ts

2707 - include: type

2708 - include: punctuation-comma

2709 type-paren-or-function-parameters:

2710 - match: \(

2711 captures:

2712 0: meta.brace.round.ts

2713 push:

2714 - meta_scope: meta.type.paren.cover.ts

2715 - match: \)

2716 captures:

2717 0: meta.brace.round.ts

2718 pop: true

2719 - include: destructuring-parameter

2720 - match: |-

2722 (<) |

2723 ([(]\s*(

2724 ([)]) |

2725 (\.\.\.) |

2726 ([_$[:alnum:]]+\s*(

2727 ([:,?=])|

2728 ([)]\s*=>)

2729 ))

2730 ))

2731 )) |

2732 (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$))))

2733 captures:

2734 1: storage.modifier.ts

2735 2: keyword.operator.rest.ts

2736 3: entity.name.function.ts variable.language.this.ts

2737 4: entity.name.function.ts

2738 5: keyword.operator.optional.ts

2740 captures:

2741 1: storage.modifier.ts

2742 2: keyword.operator.rest.ts

2743 3: variable.parameter.ts variable.language.this.ts

2744 4: variable.parameter.ts

2745 5: keyword.operator.optional.ts

2746 - include: type-annotation

2747 - match: ","

2748 scope: punctuation.separator.parameter.ts

2749 - include: type

2750 type-predicate-operator:

2751 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))is(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

2752 scope: keyword.operator.expression.is.ts

2753 type-primitive:

2755 scope: support.type.primitive.ts

2756 type-tuple:

2757 - match: '\['

2758 captures:

2759 0: meta.brace.square.ts

2760 push:

2761 - meta_scope: meta.type.tuple.ts

2762 - match: '\]'

2763 captures:

2764 0: meta.brace.square.ts

2765 pop: true

2766 - include: type

2767 - include: punctuation-comma

2768 typeof-operator:

2769 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))typeof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

2770 scope: keyword.operator.expression.typeof.ts

2771 undefined-literal:

2772 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))undefined(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

2773 scope: constant.language.undefined.ts

2774 var-expr:

2775 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

2776 captures:

2777 1: keyword.control.export.ts

2778 2: storage.type.ts

2779 push:

2780 - meta_scope: meta.var.expr.ts

2781 - 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*$)))'

2782 pop: true

2783 - include: destructuring-variable

2784 - include: var-single-variable

2785 - include: variable-initializer

2786 - include: comment

2787 - match: (,)\s*(?!\S)

2788 captures:

2789 1: punctuation.separator.comma.ts

2790 push:

2791 - match: '(?<!,)(((?==|;|}|(\s+(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$)))'

2792 pop: true

2793 - include: comment

2794 - include: destructuring-variable

2795 - include: var-single-variable

2796 - include: punctuation-comma

2797 - include: punctuation-comma

2798 - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'

2799 captures:

2800 1: keyword.control.export.ts

2801 2: storage.type.ts

2802 push:

2803 - meta_scope: meta.var.expr.ts

2804 - 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*$)))'

2805 pop: true

2806 - include: destructuring-const

2807 - include: var-single-const

2808 - include: variable-initializer

2809 - include: comment

2810 - match: (,)\s*(?!\S)

2811 captures:

2812 1: punctuation.separator.comma.ts

2813 push:

2814 - match: '(?<!,)(((?==|;|}|(\s+(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$)))'

2815 pop: true

2816 - include: comment

2817 - include: destructuring-const

2818 - include: var-single-const

2819 - include: punctuation-comma

2820 - include: punctuation-comma

2821 var-single-const:

2822 - match: |-

2823 (?x)([_$[:alpha:]][_$[:alnum:]]*)(?=\s*

2824 # function assignment |

2825 (=\s*(

2826 ((async\s+)?(

2827 (function\s*[(<*]) |

2828 (function\s+) |

2829 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

2830 )) |

2831 ((async\s*)?(

2832 ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$)) |

2833 # sure shot arrow functions even if => is on new line

2834 (

2835 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

2836 [(]\s*

2837 (

2838 ([)]\s*:) | # ():

2839 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

2840 )

2841 ) |

2842 (

2843 [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

2844 ) |

2845 # arrow function possible to detect only with => on same line

2846 (

2847 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

2848 $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

2849 (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

2850 \s*=> # arrow operator

2851 )

2852 ))

2853 )) |

2855 (:\s*(

2856 (<) |

2857 ([(]\s*(

2858 ([)]) |

2859 (\.\.\.) |

2860 ([_$[:alnum:]]+\s*(

2861 ([:,?=])|

2862 ([)]\s*=>)

2863 ))

2864 ))

2865 )) |

2866 (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$))) |

2867 (:\s*(=>|($([^\($]|($[^\($]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

2868 ((async\s+)?(

2869 (function\s*[(<*]) |

2870 (function\s+) |

2871 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

2872 )) |

2873 ((async\s*)?(

2874 ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$)) |

2875 # sure shot arrow functions even if => is on new line

2876 (

2877 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

2878 [(]\s*

2879 (

2880 ([)]\s*:) | # ():

2881 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

2882 )

2883 ) |

2884 (

2885 [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

2886 ) |

2887 # arrow function possible to detect only with => on same line

2888 (

2889 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

2890 $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

2891 (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

2892 \s*=> # arrow operator

2893 )

2894 ))

2895 )))

2896 captures:

2897 1: meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts

2898 push:

2899 - meta_scope: meta.var-single-variable.expr.ts

2900 - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

2901 pop: true

2902 - include: var-single-variable-type-annotation

2903 - match: "([_$[:alpha:]][_$[:alnum:]]*)"

2904 captures:

2905 1: meta.definition.variable.ts variable.other.constant.ts

2906 push:

2907 - meta_scope: meta.var-single-variable.expr.ts

2908 - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

2909 pop: true

2910 - include: var-single-variable-type-annotation

2911 var-single-variable:

2912 - match: |-

2913 (?x)([_$[:alpha:]][_$[:alnum:]]*)(?=\s*

2914 # function assignment |

2915 (=\s*(

2916 ((async\s+)?(

2917 (function\s*[(<*]) |

2918 (function\s+) |

2919 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

2920 )) |

2921 ((async\s*)?(

2922 ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$)) |

2923 # sure shot arrow functions even if => is on new line

2924 (

2925 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

2926 [(]\s*

2927 (

2928 ([)]\s*:) | # ():

2929 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

2930 )

2931 ) |

2932 (

2933 [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

2934 ) |

2935 # arrow function possible to detect only with => on same line

2936 (

2937 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

2938 $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

2939 (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

2940 \s*=> # arrow operator

2941 )

2942 ))

2943 )) |

2945 (:\s*(

2946 (<) |

2947 ([(]\s*(

2948 ([)]) |

2949 (\.\.\.) |

2950 ([_$[:alnum:]]+\s*(

2951 ([:,?=])|

2952 ([)]\s*=>)

2953 ))

2954 ))

2955 )) |

2956 (:\s*((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$))) |

2957 (:\s*(=>|($([^\($]|($[^\($]*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(

2958 ((async\s+)?(

2959 (function\s*[(<*]) |

2960 (function\s+) |

2961 ([_$[:alpha:]][_$[:alnum:]]*\s*=>)

2962 )) |

2963 ((async\s*)?(

2964 ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?[\(]\s*([\{\[]\s*)?$)) |

2965 # sure shot arrow functions even if => is on new line

2966 (

2967 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)?

2968 [(]\s*

2969 (

2970 ([)]\s*:) | # ():

2971 ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:

2972 )

2973 ) |

2974 (

2975 [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends

2976 ) |

2977 # arrow function possible to detect only with => on same line

2978 (

2979 (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|($([^\($]|($[^\($]*\)))*\))|(\[([^\[\]]|(\[[^\[\]]*\]))*\]))([^=<>]|=[^<])*\>)*>\s*)? # typeparameters

2980 $\s*(([_$[:alpha:]]|(\{([^\{\}]|(\{[^\{\}]*\}))*\})|(\[([^\[\]]|(\[[^\[\]]*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()]|(\(([^\($]|($[^\($]*\)))*\)))*)?\) # parameters

2981 (\s*:\s*([^<>]|\<[^<>]+\>|$[^\($]+\))+)? # return type

2982 \s*=> # arrow operator

2983 )

2984 ))

2985 )))

2986 captures:

2987 1: meta.definition.variable.ts entity.name.function.ts

2988 push:

2989 - meta_scope: meta.var-single-variable.expr.ts

2990 - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

2991 pop: true

2992 - include: var-single-variable-type-annotation

2993 - match: "([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])"

2994 captures:

2995 1: meta.definition.variable.ts variable.other.constant.ts

2996 push:

2997 - meta_scope: meta.var-single-variable.expr.ts

2998 - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

2999 pop: true

3000 - include: var-single-variable-type-annotation

3001 - match: "([_$[:alpha:]][_$[:alnum:]]*)"

3002 captures:

3003 1: meta.definition.variable.ts variable.other.readwrite.ts

3004 push:

3005 - meta_scope: meta.var-single-variable.expr.ts

3006 - match: '(?=$|^|[;,=}]|(\s+(of|in)\s+))'

3007 pop: true

3008 - include: var-single-variable-type-annotation

3009 var-single-variable-type-annotation:

3010 - include: type-annotation

3011 - include: string

3012 - include: comment

3013 variable-initializer:

3014 - match: (?<!=|!)(=)(?!=)(?=\s*\S)

3015 captures:

3016 1: keyword.operator.assignment.ts

3017 push:

3018 - match: '(?=$|^|[,);}\]])'

3019 pop: true

3020 - include: expression

3021 - match: (?<!=|!)(=)(?!=)

3022 captures:

3023 1: keyword.operator.assignment.ts

3024 push:

3025 - match: '(?=[,);}\]])|(?=^\s*$)|(?<=\S)(?<!=)(?=\s*$)'

3026 pop: true

3027 - include: expression