@@ -1,3580 +0,0 @@
3−# http://www.sublimetext.com/docs/3/syntax.html
10− - include: directives
11− - include: statements
16− 0: punctuation.definition.comment.tsx
18− - meta_scope: comment.block.documentation.tsx
21− 0: punctuation.definition.comment.tsx
24− - match: (/\*)(?:\s*((@)internal)(?=\s|(\*/)))?
26− 1: punctuation.definition.comment.tsx
27− 2: storage.type.internaldeclaration.tsx
28− 3: punctuation.decorator.internaldeclaration.tsx
30− - meta_scope: comment.block.tsx
33− 0: punctuation.definition.comment.tsx
35− - match: '(^[ \t]+)?((//)(?:\s*((@)internal)(?=\s|$))?)'
37− 1: punctuation.whitespace.comment.leading.tsx
38− 2: comment.line.double-slash.tsx
39− 3: punctuation.definition.comment.tsx
40− 4: storage.type.internaldeclaration.tsx
41− 5: punctuation.decorator.internaldeclaration.tsx
43− - meta_content_scope: comment.line.double-slash.tsx
47− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(abstract|declare|override|public|protected|private|readonly|static)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
48− scope: storage.modifier.tsx
49− after-operator-block-as-object-literal:
50− - match: '(?<!\+\+|--)(?<=[:=(,\[?+!>]|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^yield|[^\._$[:alnum:]]yield|^throw|[^\._$[:alnum:]]throw|^in|[^\._$[:alnum:]]in|^of|[^\._$[:alnum:]]of|^typeof|[^\._$[:alnum:]]typeof|&&|\|\||\*)\s*(\{)'
52− 1: punctuation.definition.block.tsx
54− - meta_scope: meta.objectliteral.tsx
57− 0: punctuation.definition.block.tsx
59− - include: object-member
60− array-binding-pattern:
61− - match: '(?:(\.\.\.)\s*)?(\[)'
63− 1: keyword.operator.rest.tsx
64− 2: punctuation.definition.binding-pattern.array.tsx
68− 0: punctuation.definition.binding-pattern.array.tsx
70− - include: binding-element
71− - include: punctuation-comma
72− array-binding-pattern-const:
73− - match: '(?:(\.\.\.)\s*)?(\[)'
75− 1: keyword.operator.rest.tsx
76− 2: punctuation.definition.binding-pattern.array.tsx
80− 0: punctuation.definition.binding-pattern.array.tsx
82− - include: binding-element-const
83− - include: punctuation-comma
87− 1: meta.brace.square.tsx
89− - meta_scope: meta.array.literal.tsx
92− 0: meta.brace.square.tsx
94− - include: expression
95− - include: punctuation-comma
97− - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync)\s+)?([_$[:alpha:]][_$[:alnum:]]*)\s*(?==>)'
98− scope: meta.arrow.tsx
100− 1: storage.modifier.async.tsx
101− 2: variable.parameter.tsx
104− (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync)
107− # sure shot arrow functions even if => is on new line
109− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
110− [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
113− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:
117− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
119− # arrow function possible to detect only with => on same line
121− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters
122− \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters
123− (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type
124− \s*=> # arrow operator
129− 1: storage.modifier.async.tsx
131− - meta_scope: meta.arrow.tsx
132− - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))'
135− - include: type-parameters
136− - include: function-parameters
137− - include: arrow-return-type
138− - include: possibly-arrow-return-type
141− 0: storage.type.function.arrow.tsx
143− - meta_scope: meta.arrow.tsx
144− - match: '((?<=\}|\S)(?<!=>)|((?!\{)(?=\S)))(?!\/[\/\*])'
146− - include: single-line-comment-consuming-line-ending
147− - include: decl-block
148− - include: expression
150− - match: (?<=\))\s*(:)
152− 1: keyword.operator.type.annotation.tsx
154− - meta_scope: meta.return.type.arrow.tsx
155− - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))'
157− - include: arrow-return-type-body
158− arrow-return-type-body:
159− - match: '(?<=[:])(?=\s*\{)'
163− - include: type-object
164− - include: type-predicate-operator
167− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(async)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
168− scope: storage.modifier.async.tsx
172− - include: numeric-literal
174− - include: object-binding-pattern
175− - include: array-binding-pattern
176− - include: destructuring-variable-rest
177− - include: variable-initializer
178− binding-element-const:
181− - include: numeric-literal
183− - include: object-binding-pattern-const
184− - include: array-binding-pattern-const
185− - include: destructuring-variable-rest-const
186− - include: variable-initializer
188− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))true(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
189− scope: constant.language.boolean.true.tsx
190− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))false(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
191− scope: constant.language.boolean.false.tsx
195− - match: '}|(?=\*/)'
200− - match: '\]|(?=\*/)'
206− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(?:(abstract)\s+)?\b(class)\b(?=\s+|/[/*])'
208− 1: keyword.control.export.tsx
209− 2: storage.modifier.tsx
210− 3: storage.modifier.tsx
211− 4: storage.type.class.tsx
213− - meta_scope: meta.class.tsx
216− - include: class-declaration-or-expression-patterns
217− class-declaration-or-expression-patterns:
219− - include: class-or-interface-heritage
220− - match: "[_$[:alpha:]][_$[:alnum:]]*"
222− 0: entity.name.type.class.tsx
223− - include: type-parameters
224− - include: class-or-interface-body
226− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(class)\b(?=\s+|[<{]|\/[\/*])'
228− 1: storage.modifier.tsx
229− 2: storage.type.class.tsx
231− - meta_scope: meta.class.tsx
234− - include: class-declaration-or-expression-patterns
235− class-or-interface-body:
238− 0: punctuation.definition.block.tsx
242− 0: punctuation.definition.block.tsx
245− - include: decorator
248− - match: '(?=\s|[;),}\]:\-\+]|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
250− - include: expression
251− - include: method-declaration
252− - include: indexer-declaration
253− - include: field-declaration
255− - include: type-annotation
256− - include: variable-initializer
257− - include: access-modifier
258− - include: property-accessor
259− - include: async-modifier
260− - include: after-operator-block-as-object-literal
261− - include: decl-block
262− - include: expression
263− - include: punctuation-comma
264− - include: punctuation-semicolon
265− class-or-interface-heritage:
266− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(extends|implements)\b)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
268− 1: storage.modifier.tsx
273− - include: class-or-interface-heritage
274− - include: type-parameters
275− - include: expressionWithoutIdentifiers
276− - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))(?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)*\s*)'
278− 1: entity.name.type.module.tsx
279− 2: punctuation.accessor.tsx
280− 3: punctuation.accessor.optional.tsx
281− - match: "([_$[:alpha:]][_$[:alnum:]]*)"
283− 1: entity.other.inherited-class.tsx
284− - include: expressionPunctuations
286− - include: switch-statement
288− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(catch|finally|throw|try)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
289− scope: keyword.control.trycatch.tsx
290− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(break|continue|goto)\s+([_$[:alpha:]][_$[:alnum:]]*)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
292− 1: keyword.control.loop.tsx
293− 2: entity.name.label.tsx
294− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(break|continue|do|goto|while)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
295− scope: keyword.control.loop.tsx
296− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(return)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
298− 0: keyword.control.flow.tsx
300− - match: '(?=[;}]|$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
302− - include: expression
303− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default|switch)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
304− scope: keyword.control.switch.tsx
305− - include: if-statement
306− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(else|if)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
307− scope: keyword.control.conditional.tsx
308− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(with)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
309− scope: keyword.control.with.tsx
310− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(package)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
311− scope: keyword.control.tsx
312− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(debugger)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
313− scope: keyword.other.debugger.tsx
317− 0: punctuation.definition.block.tsx
319− - meta_scope: meta.block.tsx
322− 0: punctuation.definition.block.tsx
324− - include: statements
326− - include: decorator
328− - include: function-declaration
329− - include: class-declaration
330− - include: interface-declaration
331− - include: enum-declaration
332− - include: namespace-declaration
333− - include: type-alias-declaration
334− - include: import-equals-declaration
335− - include: import-declaration
336− - include: export-declaration
337− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(declare|export)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
338− scope: storage.modifier.tsx
340− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))\@'
342− 0: punctuation.decorator.tsx
344− - meta_scope: meta.decorator.tsx
347− - include: expression
348− destructuring-const:
349− - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\{)'
351− - meta_scope: meta.object-binding-pattern-variable.tsx
352− - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'
354− - include: object-binding-pattern-const
355− - include: type-annotation
357− - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\[)'
359− - meta_scope: meta.array-binding-pattern-variable.tsx
360− - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'
362− - include: array-binding-pattern-const
363− - include: type-annotation
365− destructuring-parameter:
366− - match: '(?<!=|:)\s*(?:(\.\.\.)\s*)?(\{)'
368− 1: keyword.operator.rest.tsx
369− 2: punctuation.definition.binding-pattern.object.tsx
371− - meta_scope: meta.parameter.object-binding-pattern.tsx
374− 0: punctuation.definition.binding-pattern.object.tsx
376− - include: parameter-object-binding-element
377− - match: '(?<!=|:)\s*(?:(\.\.\.)\s*)?(\[)'
379− 1: keyword.operator.rest.tsx
380− 2: punctuation.definition.binding-pattern.array.tsx
382− - meta_scope: meta.paramter.array-binding-pattern.tsx
385− 0: punctuation.definition.binding-pattern.array.tsx
387− - include: parameter-binding-element
388− - include: punctuation-comma
389− destructuring-parameter-rest:
390− - match: '(?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*)'
392− 1: keyword.operator.rest.tsx
393− 2: variable.parameter.tsx
394− destructuring-variable:
395− - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\{)'
397− - meta_scope: meta.object-binding-pattern-variable.tsx
398− - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'
400− - include: object-binding-pattern
401− - include: type-annotation
403− - match: '(?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\[)'
405− - meta_scope: meta.array-binding-pattern-variable.tsx
406− - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'
408− - include: array-binding-pattern
409− - include: type-annotation
411− destructuring-variable-rest:
412− - match: '(?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*)'
414− 1: keyword.operator.rest.tsx
415− 2: meta.definition.variable.tsx variable.other.readwrite.tsx
416− destructuring-variable-rest-const:
417− - match: '(?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*)'
419− 1: keyword.operator.rest.tsx
420− 2: meta.definition.variable.tsx variable.other.constant.tsx
422− - match: '^(///)\s*(?=<(reference|amd-dependency|amd-module)(\s+(path|types|no-default-lib|lib|name)\s*=\s*((\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)))+\s*/>\s*$)'
424− 1: punctuation.definition.comment.tsx
426− - meta_scope: comment.line.triple-slash.directive.tsx
429− - match: (<)(reference|amd-dependency|amd-module)
431− 1: punctuation.definition.tag.directive.tsx
432− 2: entity.name.tag.directive.tsx
434− - meta_scope: meta.tag.tsx
437− 0: punctuation.definition.tag.directive.tsx
439− - match: path|types|no-default-lib|lib|name
440− scope: entity.other.attribute-name.directive.tsx
442− scope: keyword.operator.assignment.tsx
449− (private|protected|public)
452− 1: storage.type.class.jsdoc
453− 2: punctuation.definition.block.tag.jsdoc
454− 3: constant.language.access-type.jsdoc
461− (?:[^@<>*/]|\*[^/])*
470− 1: storage.type.class.jsdoc
471− 2: punctuation.definition.block.tag.jsdoc
472− 3: entity.name.type.instance.jsdoc
473− 4: punctuation.definition.bracket.angle.begin.jsdoc
474− 5: constant.other.email.link.underline.jsdoc
475− 6: punctuation.definition.bracket.angle.end.jsdoc
479− ((?:[^@\s*/]|\*[^/])+) # <that namepath>
481− ((?:[^@\s*/]|\*[^/])+) # <this namepath>
483− 1: storage.type.class.jsdoc
484− 2: punctuation.definition.block.tag.jsdoc
485− 3: entity.name.type.instance.jsdoc
486− 4: keyword.operator.control.jsdoc
487− 5: entity.name.type.instance.jsdoc
488− - match: ((@)example)\s+
490− 1: storage.type.class.jsdoc
491− 2: punctuation.definition.block.tag.jsdoc
493− - meta_scope: meta.example.jsdoc
497− - match: \G(<)caption(>)
499− 0: entity.name.tag.inline.jsdoc
500− 1: punctuation.definition.bracket.angle.begin.jsdoc
501− 2: punctuation.definition.bracket.angle.end.jsdoc
503− - meta_content_scope: constant.other.description.jsdoc
504− - match: (</)caption(>)|(?=\*/)
506− 0: entity.name.tag.inline.jsdoc
507− 1: punctuation.definition.bracket.angle.begin.jsdoc
508− 2: punctuation.definition.bracket.angle.end.jsdoc
510− - match: '[^\s@*](?:[^*]|\*[^/])*'
512− 0: source.embedded.tsx
513− - match: (?x) ((@)kind) \s+ (class|constant|event|external|file|function|member|mixin|module|namespace|typedef) \b
515− 1: storage.type.class.jsdoc
516− 2: punctuation.definition.block.tag.jsdoc
517− 3: constant.language.symbol-type.jsdoc
532− # Avoid matching bare URIs (also acceptable as links)
535− # Avoid matching {@inline tags}; we match those below
536− (?:\[[^\[\]]*\])? # Possible description [preceding]{@tag}
537− {@(?:link|linkcode|linkplain|tutorial)\b
540− (?:[^@\s*/]|\*[^/])+
544− 1: storage.type.class.jsdoc
545− 2: punctuation.definition.block.tag.jsdoc
546− 3: variable.other.link.underline.jsdoc
547− 4: entity.name.type.instance.jsdoc
552− # One or more valid identifiers
554− [A-Za-z_$] # First character: non-numeric word character
555− [\w$.\[\]]* # Rest of identifier
556− (?: # Possible list of additional identifiers
563− 1: storage.type.class.jsdoc
564− 2: punctuation.definition.block.tag.jsdoc
565− 3: variable.other.jsdoc
570− (?:arg|argument|const|constant|member|namespace|param|var)
578− 1: storage.type.class.jsdoc
579− 2: punctuation.definition.block.tag.jsdoc
580− 3: variable.other.jsdoc
581− - match: '((@)typedef)\s+(?={)'
583− 1: storage.type.class.jsdoc
584− 2: punctuation.definition.block.tag.jsdoc
586− - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])'
588− - include: jsdoctype
589− - match: '(?:[^@\s*/]|\*[^/])+'
590− scope: entity.name.type.instance.jsdoc
591− - match: '((@)(?:arg|argument|const|constant|member|namespace|param|prop|property|var))\s+(?={)'
593− 1: storage.type.class.jsdoc
594− 2: punctuation.definition.block.tag.jsdoc
596− - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])'
598− - include: jsdoctype
599− - match: '([A-Za-z_$][\w$.\[\]]*)'
600− scope: variable.other.jsdoc
606− (?:\[\])? # Foo[ ].bar properties within an array
607− \. # Foo.Bar namespaced parameter
612− (=) # [foo=bar] Default parameter value
615− # The inner regexes are to stop the match early at */ and to not stop at escaped quotes
617− "(?:(?:\*(?!/))|(?:\\(?!"))|[^*\\])*?" | # [foo="bar"] Double-quoted
618− '(?:(?:\*(?!/))|(?:\\(?!'))|[^*\\])*?' | # [foo='bar'] Single-quoted
619− \[ (?:(?:\*(?!/))|[^*])*? \] | # [foo=[1,2]] Array literal
620− (?:(?:\*(?!/))|\s(?!\s*\])|\[.*?(?:\]|(?=\*/))|[^*\s\[\]])* # Everything else
624− \s*(?:(\])((?:[^*\s]|\*[^\s/])+)?|(?=\*/))
625− scope: variable.other.jsdoc
627− 1: punctuation.definition.optional-value.begin.bracket.square.jsdoc
628− 2: keyword.operator.assignment.jsdoc
629− 3: source.embedded.tsx
630− 4: punctuation.definition.optional-value.end.bracket.square.jsdoc
631− 5: invalid.illegal.syntax.jsdoc
636− (?:define|enum|exception|export|extends|lends|implements|modifies
637− |namespace|private|protected|returns?|suppress|this|throws|type
642− 1: storage.type.class.jsdoc
643− 2: punctuation.definition.block.tag.jsdoc
645− - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])'
647− - include: jsdoctype
652− (?:alias|augments|callback|constructs|emits|event|fires|exports?
653− |extends|external|function|func|host|lends|listens|interface|memberof!?
654− |method|module|mixes|mixin|name|requires|see|this|typedef|uses)
663− 1: storage.type.class.jsdoc
664− 2: punctuation.definition.block.tag.jsdoc
665− 3: entity.name.type.instance.jsdoc
666− - match: '((@)(?:default(?:value)?|license|version))\s+(([''''"]))'
668− 1: storage.type.class.jsdoc
669− 2: punctuation.definition.block.tag.jsdoc
670− 3: variable.other.jsdoc
671− 4: punctuation.definition.string.begin.jsdoc
673− - meta_content_scope: variable.other.jsdoc
674− - match: (\3)|(?=$|\*/)
676− 0: variable.other.jsdoc
677− 1: punctuation.definition.string.end.jsdoc
679− - match: '((@)(?:default(?:value)?|license|tutorial|variation|version))\s+([^\s*]+)'
681− 1: storage.type.class.jsdoc
682− 2: punctuation.definition.block.tag.jsdoc
683− 3: variable.other.jsdoc
684− - match: '(?x) (@) (?:abstract|access|alias|api|arg|argument|async|attribute|augments|author|beta|borrows|bubbles |callback|chainable|class|classdesc|code|config|const|constant|constructor|constructs|copyright |default|defaultvalue|define|deprecated|desc|description|dict|emits|enum|event|example|exception |exports?|extends|extension(?:_?for)?|external|externs|file|fileoverview|final|fires|for|func |function|generator|global|hideconstructor|host|ignore|implements|implicitCast|inherit[Dd]oc |inner|instance|interface|internal|kind|lends|license|listens|main|member|memberof!?|method |mixes|mixins?|modifies|module|name|namespace|noalias|nocollapse|nocompile|nosideeffects |override|overview|package|param|polymer(?:Behavior)?|preserve|private|prop|property|protected |public|read[Oo]nly|record|require[ds]|returns?|see|since|static|struct|submodule|summary |suppress|template|this|throws|todo|tutorial|type|typedef|unrestricted|uses|var|variation |version|virtual|writeOnce|yields?) \b'
685− scope: storage.type.class.jsdoc
687− 1: punctuation.definition.block.tag.jsdoc
688− - include: inline-tags
689− - match: '((@)(?:[_$[:alpha:]][_$[:alnum:]]*))(?=\s+)'
691− 1: storage.type.class.jsdoc
692− 2: punctuation.definition.block.tag.jsdoc
694− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?(?:\b(const)\s+)?\b(enum)\s+([_$[:alpha:]][_$[:alnum:]]*)'
696− 1: keyword.control.export.tsx
697− 2: storage.modifier.tsx
698− 3: storage.modifier.tsx
699− 4: storage.type.enum.tsx
700− 5: entity.name.type.enum.tsx
702− - meta_scope: meta.enum.declaration.tsx
708− 0: punctuation.definition.block.tsx
712− 0: punctuation.definition.block.tsx
715− - match: "([_$[:alpha:]][_$[:alnum:]]*)"
717− 0: variable.other.enummember.tsx
719− - match: '(?=,|\}|$)'
722− - include: variable-initializer
723− - match: '(?=((\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\])))'
725− - match: '(?=,|\}|$)'
728− - include: array-literal
730− - include: variable-initializer
731− - include: punctuation-comma
733− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)\s+(as)\s+(namespace)\s+([_$[:alpha:]][_$[:alnum:]]*)'
735− 1: keyword.control.export.tsx
736− 2: keyword.control.as.tsx
737− 3: storage.type.namespace.tsx
738− 4: entity.name.type.module.tsx
739− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:\s+(type))?(?:(?:\s*(=))|(?:\s+(default)(?=\s+)))'
741− 1: keyword.control.export.tsx
742− 2: keyword.control.type.tsx
743− 3: keyword.operator.assignment.tsx
744− 4: keyword.control.default.tsx
746− - meta_scope: meta.export.default.tsx
747− - match: (?=$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))
749− - include: interface-declaration
750− - include: expression
751− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:\s+(type))?\b(?!(\$)|(\s*:))((?=\s*[\{*])|((?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s|,))(?!\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b)))'
753− 1: keyword.control.export.tsx
754− 2: keyword.control.type.tsx
756− - meta_scope: meta.export.tsx
757− - match: (?=$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))
759− - include: import-export-declaration
761− - include: expressionWithoutIdentifiers
762− - include: identifiers
763− - include: expressionPunctuations
764− expression-inside-possibly-arrow-parens:
765− - include: expressionWithoutIdentifiers
768− - include: decorator
769− - include: destructuring-parameter
770− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|protected|private|readonly)\s+(?=(override|public|protected|private|readonly)\s+)'
772− 1: storage.modifier.tsx
774− (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s*
775− # function assignment |
778− (function\s*[(<*]) |
780− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
783− ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
784− # sure shot arrow functions even if => is on new line
786− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
787− [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
790− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:
794− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
796− # arrow function possible to detect only with => on same line
798− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters
799− \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters
800− (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type
801− \s*=> # arrow operator
805− # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) =>
817− (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |
818− (:\s*((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
819− (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
821− (function\s*[(<*]) |
823− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
826− ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
827− # sure shot arrow functions even if => is on new line
829− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
830− [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
833− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:
837− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
839− # arrow function possible to detect only with => on same line
841− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters
842− \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters
843− (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type
844− \s*=> # arrow operator
849− 1: storage.modifier.tsx
850− 2: keyword.operator.rest.tsx
851− 3: entity.name.function.tsx variable.language.this.tsx
852− 4: entity.name.function.tsx
853− 5: keyword.operator.optional.tsx
854− - match: '(?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s*[:,]|$)'
856− 1: storage.modifier.tsx
857− 2: keyword.operator.rest.tsx
858− 3: variable.parameter.tsx variable.language.this.tsx
859− 4: variable.parameter.tsx
860− 5: keyword.operator.optional.tsx
861− - include: type-annotation
862− - include: variable-initializer
864− scope: punctuation.separator.parameter.tsx
865− - include: identifiers
866− - include: expressionPunctuations
867− expression-operators:
868− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(await)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
869− scope: keyword.control.flow.tsx
870− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(yield)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?=\s*\/\*([^\*]|(\*[^\/]))*\*\/\s*\*)'
872− 1: keyword.control.flow.tsx
876− 0: keyword.generator.asterisk.tsx
879− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(yield)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?:\s*(\*))?'
881− 1: keyword.control.flow.tsx
882− 2: keyword.generator.asterisk.tsx
883− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))delete(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
884− scope: keyword.operator.expression.delete.tsx
885− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))in(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?!\()'
886− scope: keyword.operator.expression.in.tsx
887− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))of(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?!\()'
888− scope: keyword.operator.expression.of.tsx
889− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))instanceof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
890− scope: keyword.operator.expression.instanceof.tsx
891− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
892− scope: keyword.operator.new.tsx
893− - include: typeof-operator
894− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))void(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
895− scope: keyword.operator.expression.void.tsx
896− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+(const)(?=\s*($|[;,:})\]]))'
898− 1: keyword.control.as.tsx
899− 2: storage.modifier.tsx
900− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+'
902− 1: keyword.control.as.tsx
904− - match: '(?=^|[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+)|(\s+\<))'
908− scope: keyword.operator.spread.tsx
909− - match: \*=|(?<!\()/=|%=|\+=|\-=
910− scope: keyword.operator.assignment.compound.tsx
911− - match: \&=|\^=|<<=|>>=|>>>=|\|=
912− scope: keyword.operator.assignment.compound.bitwise.tsx
913− - match: "<<|>>>|>>"
914− scope: keyword.operator.bitwise.shift.tsx
915− - match: "===|!==|==|!="
916− scope: keyword.operator.comparison.tsx
917− - match: <=|>=|<>|<|>
918− scope: keyword.operator.relational.tsx
919− - match: '(?<=[_$[:alnum:]])(\!)\s*(?:(/=)|(?:(/)(?![/*])))'
921− 1: keyword.operator.logical.tsx
922− 2: keyword.operator.assignment.compound.tsx
923− 3: keyword.operator.arithmetic.tsx
924− - match: \!|&&|\|\||\?\?
925− scope: keyword.operator.logical.tsx
927− scope: keyword.operator.bitwise.tsx
929− scope: keyword.operator.assignment.tsx
931− scope: keyword.operator.decrement.tsx
933− scope: keyword.operator.increment.tsx
934− - match: '%|\*|/|-|\+'
935− scope: keyword.operator.arithmetic.tsx
936− - match: '(?<=[_$[:alnum:])\]])\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)+(?:(/=)|(?:(/)(?![/*]))))'
938− - match: '(?:(/=)|(?:(/)(?!\*([^\*]|(\*[^\/]))*\*\/)))'
940− 1: keyword.operator.assignment.compound.tsx
941− 2: keyword.operator.arithmetic.tsx
944− - match: '(?<=[_$[:alnum:])\]])\s*(?:(/=)|(?:(/)(?![/*])))'
946− 1: keyword.operator.assignment.compound.tsx
947− 2: keyword.operator.arithmetic.tsx
948− expressionPunctuations:
949− - include: punctuation-comma
950− - include: punctuation-accessor
951− expressionWithoutIdentifiers:
956− - include: function-expression
957− - include: class-expression
958− - include: arrow-function
959− - include: paren-expression-possibly-arrow
961− - include: ternary-expression
963− - include: instanceof-expr
964− - include: object-literal
965− - include: expression-operators
966− - include: function-call
968− - include: support-objects
969− - include: paren-expression
972− (?x)(?<!\()(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s+)?(?=\s*((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?:
973− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3
974− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3
975− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3
976− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3
977− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1
978− (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.
979− (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1
980− (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1
981− )(?!\$))|(\#?[_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(?:(?:(\?)|(\!))\s*)?(=|:|;|,|\}|$))
983− 1: storage.modifier.tsx
985− - meta_scope: meta.field.declaration.tsx
987− (?x)(?=\}|;|,|$|(^(?!\s*((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?:
988− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3
989− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3
990− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3
991− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3
992− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1
993− (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.
994− (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1
995− (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1
996− )(?!\$))|(\#?[_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(?:(?:(\?)|(\!))\s*)?(=|:|;|,|$))))|(?<=\})
998− - include: variable-initializer
999− - include: type-annotation
1001− - include: array-literal
1002− - include: numeric-literal
1005− (?x)(\#?[_$[:alpha:]][_$[:alnum:]]*)(?:(\?)|(\!))?(?=\s*\s*
1006− # function assignment |
1009− (function\s*[(<*]) |
1011− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
1014− ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
1015− # sure shot arrow functions even if => is on new line
1017− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
1018− [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
1021− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:
1025− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
1027− # arrow function possible to detect only with => on same line
1029− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters
1030− \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters
1031− (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type
1032− \s*=> # arrow operator
1036− # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) =>
1042− ([_$[:alnum:]]+\s*(
1048− (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |
1049− (:\s*((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
1050− (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
1052− (function\s*[(<*]) |
1054− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
1057− ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
1058− # sure shot arrow functions even if => is on new line
1060− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
1061− [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
1064− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:
1068− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
1070− # arrow function possible to detect only with => on same line
1072− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters
1073− \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters
1074− (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type
1075− \s*=> # arrow operator
1080− 1: meta.definition.property.tsx entity.name.function.tsx
1081− 2: keyword.operator.optional.tsx
1082− 3: keyword.operator.definiteassignment.tsx
1083− - match: '\#?[_$[:alpha:]][_$[:alnum:]]*'
1084− scope: meta.definition.property.tsx variable.object.property.tsx
1086− scope: keyword.operator.optional.tsx
1088− scope: keyword.operator.definiteassignment.tsx
1090− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))for(?=((\s+|(\s*\/\*([^\*]|(\*[^\/]))*\*\/\s*))await)?\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)?(\())'
1092− 0: keyword.control.loop.tsx
1098− scope: keyword.control.loop.tsx
1101− 0: meta.brace.round.tsx
1105− 0: meta.brace.round.tsx
1107− - include: var-expr
1108− - include: expression
1109− - include: punctuation-semicolon
1112− - include: type-parameters
1113− - include: function-parameters
1114− - include: return-type
1115− - include: type-function-return-type
1116− - include: decl-block
1118− scope: keyword.generator.asterisk.tsx
1120− - match: '(?=(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\())'
1122− - match: '(?<=\))(?!(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\())'
1124− - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))'
1126− - meta_scope: meta.function-call.tsx
1127− - match: '(?=\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\())'
1129− - include: function-call-target
1131− - include: function-call-optionals
1132− - include: type-arguments
1133− - include: paren-expression
1134− - match: '(?=(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))(<\s*[\{\[\(]\s*$))'
1136− - match: '(?<=\>)(?!(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))(<\s*[\{\[\(]\s*$))'
1138− - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))'
1140− - meta_scope: meta.function-call.tsx
1141− - match: '(?=(<\s*[\{\[\(]\s*$))'
1143− - include: function-call-target
1145− - include: function-call-optionals
1146− - include: type-arguments
1147− function-call-optionals:
1149− scope: meta.function-call.tsx punctuation.accessor.optional.tsx
1151− scope: meta.function-call.tsx keyword.operator.definiteassignment.tsx
1152− function-call-target:
1153− - include: support-function-call-identifiers
1154− - match: '(\#?[_$[:alpha:]][_$[:alnum:]]*)'
1155− scope: entity.name.function.tsx
1156− function-declaration:
1157− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'
1159− 1: keyword.control.export.tsx
1160− 2: storage.modifier.tsx
1161− 3: storage.modifier.async.tsx
1162− 4: storage.type.function.tsx
1163− 5: keyword.generator.asterisk.tsx
1164− 6: meta.definition.function.tsx entity.name.function.tsx
1166− - meta_scope: meta.function.tsx
1167− - match: '(?=;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))|(?<=\})'
1169− - include: function-name
1170− - include: function-body
1171− function-expression:
1172− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s*'
1174− 1: storage.modifier.async.tsx
1175− 2: storage.type.function.tsx
1176− 3: keyword.generator.asterisk.tsx
1177− 4: meta.definition.function.tsx entity.name.function.tsx
1179− - meta_scope: meta.function.expression.tsx
1180− - match: '(?=;)|(?<=\})'
1182− - include: function-name
1183− - include: single-line-comment-consuming-line-ending
1184− - include: function-body
1186− - match: "[_$[:alpha:]][_$[:alnum:]]*"
1187− scope: meta.definition.function.tsx entity.name.function.tsx
1188− function-parameters:
1191− 0: punctuation.definition.parameters.begin.tsx
1193− - meta_scope: meta.parameters.tsx
1196− 0: punctuation.definition.parameters.end.tsx
1198− - include: function-parameters-body
1199− function-parameters-body:
1202− - include: decorator
1203− - include: destructuring-parameter
1204− - include: parameter-name
1205− - include: parameter-type-annotation
1206− - include: variable-initializer
1208− scope: punctuation.separator.parameter.tsx
1210− - include: object-identifiers
1212− (?x)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*)?([_$[:alpha:]][_$[:alnum:]]*)(?=\s*=\s*(
1214− (function\s*[(<*]) |
1216− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
1219− ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
1220− # sure shot arrow functions even if => is on new line
1222− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
1223− [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
1226− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:
1230− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
1232− # arrow function possible to detect only with => on same line
1234− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters
1235− \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters
1236− (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type
1237− \s*=> # arrow operator
1242− 1: punctuation.accessor.tsx
1243− 2: punctuation.accessor.optional.tsx
1244− 3: entity.name.function.tsx
1245− - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(\#?[[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])'
1247− 1: punctuation.accessor.tsx
1248− 2: punctuation.accessor.optional.tsx
1249− 3: variable.other.constant.property.tsx
1250− - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(\#?[_$[:alpha:]][_$[:alnum:]]*)'
1252− 1: punctuation.accessor.tsx
1253− 2: punctuation.accessor.optional.tsx
1254− 3: variable.other.property.tsx
1255− - match: "([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])"
1256− scope: variable.other.constant.tsx
1257− - match: "[_$[:alpha:]][_$[:alnum:]]*"
1258− scope: variable.other.readwrite.tsx
1260− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bif\s*(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))\s*(?!\{))'
1262− - match: '(?=;|$|\})'
1265− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(if)\s*(\()'
1267− 1: keyword.control.conditional.tsx
1268− 2: meta.brace.round.tsx
1272− 0: meta.brace.round.tsx
1274− - include: expression
1275− - match: '(?<=\))\s*\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'
1277− 0: punctuation.definition.string.begin.tsx
1279− - meta_scope: string.regexp.tsx
1280− - match: "(/)([dgimsuy]*)"
1282− 1: punctuation.definition.string.end.tsx
1283− 2: keyword.other.tsx
1286− - include: statements
1287− import-declaration:
1288− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(import)(?:\s+(type)(?!\s+from))?(?!\s*[:\(])(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
1290− 1: keyword.control.export.tsx
1291− 2: storage.modifier.tsx
1292− 3: keyword.control.import.tsx
1293− 4: keyword.control.type.tsx
1295− - meta_scope: meta.import.tsx
1296− - match: '(?<!^import|[^\._$[:alnum:]]import)(?=;|$|^)'
1298− - include: single-line-comment-consuming-line-ending
1301− - match: '(?<=^import|[^\._$[:alnum:]]import)(?!\s*["''])'
1305− 0: keyword.control.from.tsx
1307− - include: import-export-declaration
1308− - include: import-export-declaration
1309− import-equals-declaration:
1310− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(import)(?:\s+(type))?\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(require)\s*(\()'
1312− 1: keyword.control.export.tsx
1313− 2: storage.modifier.tsx
1314− 3: keyword.control.import.tsx
1315− 4: keyword.control.type.tsx
1316− 5: variable.other.readwrite.alias.tsx
1317− 6: keyword.operator.assignment.tsx
1318− 7: keyword.control.require.tsx
1319− 8: meta.brace.round.tsx
1321− - meta_scope: meta.import-equals.external.tsx
1324− 0: meta.brace.round.tsx
1328− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(import)(?:\s+(type))?\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(?!require\b)'
1330− 1: keyword.control.export.tsx
1331− 2: storage.modifier.tsx
1332− 3: keyword.control.import.tsx
1333− 4: keyword.control.type.tsx
1334− 5: variable.other.readwrite.alias.tsx
1335− 6: keyword.operator.assignment.tsx
1337− - meta_scope: meta.import-equals.internal.tsx
1340− - include: single-line-comment-consuming-line-ending
1342− - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))'
1344− 1: entity.name.type.module.tsx
1345− 2: punctuation.accessor.tsx
1346− 3: punctuation.accessor.optional.tsx
1347− - match: "([_$[:alpha:]][_$[:alnum:]]*)"
1348− scope: variable.other.readwrite.tsx
1349− import-export-block:
1352− 0: punctuation.definition.block.tsx
1354− - meta_scope: meta.block.tsx
1357− 0: punctuation.definition.block.tsx
1359− - include: import-export-clause
1360− import-export-clause:
1362− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bdefault)|(\*)|(\b[_$[:alpha:]][_$[:alnum:]]*))\s+(as)\s+(?:(default(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|([_$[:alpha:]][_$[:alnum:]]*))'
1364− 1: keyword.control.default.tsx
1365− 2: constant.language.import-export-all.tsx
1366− 3: variable.other.readwrite.tsx
1367− 4: keyword.control.as.tsx
1368− 5: keyword.control.default.tsx
1369− 6: variable.other.readwrite.alias.tsx
1370− - include: punctuation-comma
1372− scope: constant.language.import-export-all.tsx
1373− - match: \b(default)\b
1374− scope: keyword.control.default.tsx
1375− - match: "([_$[:alpha:]][_$[:alnum:]]*)"
1376− scope: variable.other.readwrite.alias.tsx
1377− import-export-declaration:
1380− - include: import-export-block
1382− scope: keyword.control.from.tsx
1383− - include: import-export-clause
1384− indexer-declaration:
1385− - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s*)?\s*(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s*(?=:)'
1387− 1: storage.modifier.tsx
1388− 2: meta.brace.square.tsx
1389− 3: variable.parameter.tsx
1391− - meta_scope: meta.indexer.declaration.tsx
1392− - match: '(\])\s*(\?\s*)?|$'
1394− 1: meta.brace.square.tsx
1395− 2: keyword.operator.optional.tsx
1397− - include: type-annotation
1398− indexer-mapped-type-declaration:
1399− - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))([+-])?(readonly)\s*)?\s*(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s+(in)\s+'
1401− 1: keyword.operator.type.modifier.tsx
1402− 2: storage.modifier.tsx
1403− 3: meta.brace.square.tsx
1404− 4: entity.name.type.tsx
1405− 5: keyword.operator.expression.in.tsx
1407− - meta_scope: meta.indexer.mappedtype.declaration.tsx
1408− - match: '(\])([+-])?\s*(\?\s*)?|$'
1410− 1: meta.brace.square.tsx
1411− 2: keyword.operator.type.modifier.tsx
1412− 3: keyword.operator.optional.tsx
1414− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+'
1416− 1: keyword.control.as.tsx
1419− - match: '(\[)[^\]]+(\])(?={@(?:link|linkcode|linkplain|tutorial))'
1420− scope: constant.other.description.jsdoc
1422− 1: punctuation.definition.bracket.square.begin.jsdoc
1423− 2: punctuation.definition.bracket.square.end.jsdoc
1424− - match: '({)((@)(?:link(?:code|plain)?|tutorial))\s*'
1426− 1: punctuation.definition.bracket.curly.begin.jsdoc
1427− 2: storage.type.class.jsdoc
1428− 3: punctuation.definition.inline.tag.jsdoc
1430− - meta_scope: entity.name.type.instance.jsdoc
1431− - match: '}|(?=\*/)'
1433− 0: punctuation.definition.bracket.curly.end.jsdoc
1435− - match: '\G((?=https?://)(?:[^|}\s*]|\*[/])+)(\|)?'
1437− 1: variable.other.link.underline.jsdoc
1438− 2: punctuation.separator.pipe.jsdoc
1439− - match: '\G((?:[^{}@\s|*]|\*[^/])+)(\|)?'
1441− 1: variable.other.description.jsdoc
1442− 2: punctuation.separator.pipe.jsdoc
1444− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(instanceof)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
1446− 1: keyword.operator.expression.instanceof.tsx
1448− - match: '(?<=\))|(?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|(([\&\~\^\|]\s*)?[_$[:alpha:]][_$[:alnum:]]*\s+instanceof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(]))))'
1451− interface-declaration:
1452− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(?:(abstract)\s+)?\b(interface)\b(?=\s+|/[/*])'
1454− 1: keyword.control.export.tsx
1455− 2: storage.modifier.tsx
1456− 3: storage.modifier.tsx
1457− 4: storage.type.interface.tsx
1459− - meta_scope: meta.interface.tsx
1463− - include: class-or-interface-heritage
1464− - match: "[_$[:alpha:]][_$[:alnum:]]*"
1466− 0: entity.name.type.interface.tsx
1467− - include: type-parameters
1468− - include: class-or-interface-body
1470− - match: '\G{(?:[^}*]|\*[^/}])+$'
1471− scope: invalid.illegal.type.jsdoc
1474− 0: entity.name.type.instance.jsdoc
1475− 1: punctuation.definition.bracket.curly.begin.jsdoc
1477− - meta_content_scope: entity.name.type.instance.jsdoc
1478− - match: '((}))\s*|(?=\*/)'
1480− 1: entity.name.type.instance.jsdoc
1481− 2: punctuation.definition.bracket.curly.end.jsdoc
1483− - include: brackets
1485− - include: jsx-tag-without-attributes-in-expression
1486− - include: jsx-tag-in-expression
1488− - include: jsx-tag-without-attributes
1490− - include: jsx-evaluated-code
1491− - include: jsx-entities
1493− - match: "(&)([a-zA-Z0-9]+|#[0-9]+|#x[0-9a-fA-F]+)(;)"
1494− scope: constant.character.entity.tsx
1496− 1: punctuation.definition.entity.tsx
1497− 3: punctuation.definition.entity.tsx
1499− scope: invalid.illegal.bad-ampersand.tsx
1500− jsx-evaluated-code:
1503− 0: punctuation.section.embedded.begin.tsx
1505− - meta_content_scope: meta.embedded.expression.tsx
1508− 0: punctuation.section.embedded.end.tsx
1510− - include: expression
1511− jsx-string-double-quoted:
1514− 0: punctuation.definition.string.begin.tsx
1516− - meta_scope: string.quoted.double.tsx
1519− 0: punctuation.definition.string.end.tsx
1521− - include: jsx-entities
1522− jsx-string-single-quoted:
1525− 0: punctuation.definition.string.begin.tsx
1527− - meta_scope: string.quoted.single.tsx
1530− 0: punctuation.definition.string.end.tsx
1532− - include: jsx-entities
1534− - match: '(?=(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>))'
1536− - meta_scope: meta.tag.tsx
1537− - match: '(/>)|(?:(</)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>))'
1539− 1: punctuation.definition.tag.end.tsx
1540− 2: punctuation.definition.tag.begin.tsx
1541− 3: entity.name.tag.namespace.tsx
1542− 4: punctuation.separator.namespace.tsx
1543− 5: entity.name.tag.tsx
1544− 6: support.class.component.tsx
1545− 7: punctuation.definition.tag.end.tsx
1547− - match: '(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>)'
1549− 1: punctuation.definition.tag.begin.tsx
1550− 2: entity.name.tag.namespace.tsx
1551− 3: punctuation.separator.namespace.tsx
1552− 4: entity.name.tag.tsx
1553− 5: support.class.component.tsx
1555− - match: "(?=[/]?>)"
1558− - include: type-arguments
1559− - include: jsx-tag-attributes
1562− 1: punctuation.definition.tag.end.tsx
1564− - meta_content_scope: meta.jsx.children.tsx
1567− - include: jsx-children
1568− jsx-tag-attribute-assignment:
1569− - match: '=(?=\s*(?:''|"|{|/\*|//|\n))'
1570− scope: keyword.operator.assignment.tsx
1571− jsx-tag-attribute-name:
1575− (?:([_$[:alpha:]][-_$[:alnum:].]*)(:))?
1576− ([_$[:alpha:]][-_$[:alnum:]]*)
1577− (?=\s|=|/?>|/\*|//)
1579− 1: entity.other.attribute-name.namespace.tsx
1580− 2: punctuation.separator.namespace.tsx
1581− 3: entity.other.attribute-name.tsx
1582− jsx-tag-attributes:
1585− - meta_scope: meta.tag.attributes.tsx
1586− - match: "(?=[/]?>)"
1589− - include: jsx-tag-attribute-name
1590− - include: jsx-tag-attribute-assignment
1591− - include: jsx-string-double-quoted
1592− - include: jsx-string-single-quoted
1593− - include: jsx-evaluated-code
1594− - include: jsx-tag-attributes-illegal
1595− jsx-tag-attributes-illegal:
1597− scope: invalid.illegal.attribute.tsx
1598− jsx-tag-in-expression:
1601− (?<!\+\+|--)(?<=[({\[,?=>:*]|&&|\|\||\?|\*\/|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^default|[^\._$[:alnum:]]default|^yield|[^\._$[:alnum:]]yield|^)\s*
1602− (?!<\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s+[^=>])|,)) # look ahead is not type parameter of arrow
1603− (?=(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>))
1605− - match: '(?!(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>))'
1608− jsx-tag-without-attributes:
1609− - match: '(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>)'
1611− 1: punctuation.definition.tag.begin.tsx
1612− 2: entity.name.tag.namespace.tsx
1613− 3: punctuation.separator.namespace.tsx
1614− 4: entity.name.tag.tsx
1615− 5: support.class.component.tsx
1616− 6: punctuation.definition.tag.end.tsx
1618− - meta_scope: meta.tag.without-attributes.tsx
1619− - meta_content_scope: meta.jsx.children.tsx
1620− - match: '(</)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>)'
1622− 1: punctuation.definition.tag.begin.tsx
1623− 2: entity.name.tag.namespace.tsx
1624− 3: punctuation.separator.namespace.tsx
1625− 4: entity.name.tag.tsx
1626− 5: support.class.component.tsx
1627− 6: punctuation.definition.tag.end.tsx
1629− - include: jsx-children
1630− jsx-tag-without-attributes-in-expression:
1631− - match: '(?<!\+\+|--)(?<=[({\[,?=>:*]|&&|\|\||\?|\*\/|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^default|[^\._$[:alnum:]]default|^yield|[^\._$[:alnum:]]yield|^)\s*(?=(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>))'
1633− - match: '(?!(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>))'
1635− - include: jsx-tag-without-attributes
1637− - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(:)(?=\s*\{)'
1639− 1: entity.name.label.tsx
1640− 2: punctuation.separator.label.tsx
1644− - include: decl-block
1645− - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(:)'
1647− 1: entity.name.label.tsx
1648− 2: punctuation.separator.label.tsx
1650− - include: numeric-literal
1651− - include: boolean-literal
1652− - include: null-literal
1653− - include: undefined-literal
1654− - include: numericConstant-literal
1655− - include: array-literal
1656− - include: this-literal
1657− - include: super-literal
1658− method-declaration:
1659− - match: '(?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?\s*\b(constructor)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
1661− 1: storage.modifier.tsx
1662− 2: storage.modifier.tsx
1663− 3: storage.modifier.tsx
1664− 4: storage.modifier.async.tsx
1665− 5: storage.type.tsx
1667− - meta_scope: meta.method.declaration.tsx
1668− - match: '(?=\}|;|,|$)|(?<=\})'
1670− - include: method-declaration-name
1671− - include: function-body
1672− - match: '(?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:(?:\s*\b(new)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|(?:(\*)\s*)?)(?=\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])'
1674− 1: storage.modifier.tsx
1675− 2: storage.modifier.tsx
1676− 3: storage.modifier.tsx
1677− 4: storage.modifier.async.tsx
1678− 5: keyword.operator.new.tsx
1679− 6: keyword.generator.asterisk.tsx
1681− - meta_scope: meta.method.declaration.tsx
1682− - match: '(?=\}|;|,|$)|(?<=\})'
1684− - include: method-declaration-name
1685− - include: function-body
1687− (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=\s*(((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?:
1688− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3
1689− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3
1690− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3
1691− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3
1692− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1
1693− (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.
1694− (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1
1695− (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1
1696− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])
1698− 1: storage.modifier.tsx
1699− 2: storage.modifier.tsx
1700− 3: storage.modifier.tsx
1701− 4: storage.modifier.async.tsx
1702− 5: storage.type.property.tsx
1703− 6: keyword.generator.asterisk.tsx
1705− - meta_scope: meta.method.declaration.tsx
1706− - match: '(?=\}|;|,|$)|(?<=\})'
1708− - include: method-declaration-name
1709− - include: function-body
1710− method-declaration-name:
1712− (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?:
1713− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3
1714− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3
1715− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3
1716− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3
1717− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1
1718− (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.
1719− (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1
1720− (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1
1721− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??)\s*[\(\<])
1726− - include: array-literal
1727− - include: numeric-literal
1728− - match: "[_$[:alpha:]][_$[:alnum:]]*"
1729− scope: meta.definition.method.tsx entity.name.function.tsx
1731− scope: keyword.operator.optional.tsx
1732− namespace-declaration:
1733− - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(namespace|module)\s+(?=[_$[:alpha:]"''`]))'
1735− 1: keyword.control.export.tsx
1736− 2: storage.modifier.tsx
1737− 3: storage.type.namespace.tsx
1739− - meta_scope: meta.namespace.declaration.tsx
1740− - match: '(?<=\})|(?=;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
1744− - match: "([_$[:alpha:]][_$[:alnum:]]*)"
1745− scope: entity.name.type.module.tsx
1746− - include: punctuation-accessor
1747− - include: decl-block
1749− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
1751− 1: keyword.operator.new.tsx
1753− - meta_scope: new.expr.tsx
1754− - match: '(?<=\))|(?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(]))))'
1756− - include: expression
1758− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))null(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
1759− scope: constant.language.null.tsx
1761− - match: '\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$)'
1762− scope: constant.numeric.hex.tsx
1764− 1: storage.type.numeric.bigint.tsx
1765− - match: '\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$)'
1766− scope: constant.numeric.binary.tsx
1768− 1: storage.type.numeric.bigint.tsx
1769− - match: '\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$)'
1770− scope: constant.numeric.octal.tsx
1772− 1: storage.type.numeric.bigint.tsx
1776− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3
1777− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3
1778− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3
1779− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3
1780− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1
1781− (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.
1782− (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1
1783− (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1
1786− 0: constant.numeric.decimal.tsx
1787− 1: meta.delimiter.decimal.period.tsx
1788− 2: storage.type.numeric.bigint.tsx
1789− 3: meta.delimiter.decimal.period.tsx
1790− 4: storage.type.numeric.bigint.tsx
1791− 5: meta.delimiter.decimal.period.tsx
1792− 6: storage.type.numeric.bigint.tsx
1793− 7: storage.type.numeric.bigint.tsx
1794− 8: meta.delimiter.decimal.period.tsx
1795− 9: storage.type.numeric.bigint.tsx
1796− 10: meta.delimiter.decimal.period.tsx
1797− 11: storage.type.numeric.bigint.tsx
1798− 12: meta.delimiter.decimal.period.tsx
1799− 13: storage.type.numeric.bigint.tsx
1800− 14: storage.type.numeric.bigint.tsx
1801− numericConstant-literal:
1802− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))NaN(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
1803− scope: constant.language.nan.tsx
1804− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Infinity(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
1805− scope: constant.language.infinity.tsx
1806− object-binding-element:
1809− (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?:
1810− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3
1811− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3
1812− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3
1813− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3
1814− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1
1815− (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.
1816− (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1
1817− (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1
1818− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))
1820− - match: '(?=,|\})'
1822− - include: object-binding-element-propertyName
1823− - include: binding-element
1824− - include: object-binding-pattern
1825− - include: destructuring-variable-rest
1826− - include: variable-initializer
1827− - include: punctuation-comma
1828− object-binding-element-const:
1831− (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?:
1832− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3
1833− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3
1834− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3
1835− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3
1836− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1
1837− (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.
1838− (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1
1839− (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1
1840− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))
1842− - match: '(?=,|\})'
1844− - include: object-binding-element-propertyName
1845− - include: binding-element-const
1846− - include: object-binding-pattern-const
1847− - include: destructuring-variable-rest-const
1848− - include: variable-initializer
1849− - include: punctuation-comma
1850− object-binding-element-propertyName:
1852− (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?:
1853− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3
1854− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3
1855− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3
1856− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3
1857− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1
1858− (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.
1859− (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1
1860− (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1
1861− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))
1865− 0: punctuation.destructuring.tsx
1868− - include: array-literal
1869− - include: numeric-literal
1870− - match: "([_$[:alpha:]][_$[:alnum:]]*)"
1871− scope: variable.object.property.tsx
1872− object-binding-pattern:
1873− - match: '(?:(\.\.\.)\s*)?(\{)'
1875− 1: keyword.operator.rest.tsx
1876− 2: punctuation.definition.binding-pattern.object.tsx
1880− 0: punctuation.definition.binding-pattern.object.tsx
1882− - include: object-binding-element
1883− object-binding-pattern-const:
1884− - match: '(?:(\.\.\.)\s*)?(\{)'
1886− 1: keyword.operator.rest.tsx
1887− 2: punctuation.definition.binding-pattern.object.tsx
1891− 0: punctuation.definition.binding-pattern.object.tsx
1893− - include: object-binding-element-const
1894− object-identifiers:
1895− - match: '([_$[:alpha:]][_$[:alnum:]]*)(?=\s*\??\.\s*prototype\b(?!\$))'
1896− scope: support.class.tsx
1898− (?x)(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(?:
1899− (\#?[[:upper:]][_$[:digit:][:upper:]]*) |
1900− (\#?[_$[:alpha:]][_$[:alnum:]]*)
1901− )(?=\s*\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*)
1903− 1: punctuation.accessor.tsx
1904− 2: punctuation.accessor.optional.tsx
1905− 3: variable.other.constant.object.property.tsx
1906− 4: variable.other.object.property.tsx
1909− ([[:upper:]][_$[:digit:][:upper:]]*) |
1910− ([_$[:alpha:]][_$[:alnum:]]*)
1911− )(?=\s*\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*)
1913− 1: variable.other.constant.object.tsx
1914− 2: variable.other.object.tsx
1918− 0: punctuation.definition.block.tsx
1920− - meta_scope: meta.objectliteral.tsx
1923− 0: punctuation.definition.block.tsx
1925− - include: object-member
1926− object-literal-method-declaration:
1928− (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=\s*(((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?:
1929− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3
1930− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3
1931− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3
1932− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3
1933− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1
1934− (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.
1935− (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1
1936− (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1
1937− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])
1939− 1: storage.modifier.async.tsx
1940− 2: storage.type.property.tsx
1941− 3: keyword.generator.asterisk.tsx
1943− - meta_scope: meta.method.declaration.tsx
1944− - match: '(?=\}|;|,)|(?<=\})'
1946− - include: method-declaration-name
1947− - include: function-body
1949− (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=\s*(((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?:
1950− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3
1951− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3
1952− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3
1953− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3
1954− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1
1955− (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.
1956− (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1
1957− (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1
1958− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])
1960− 1: storage.modifier.async.tsx
1961− 2: storage.type.property.tsx
1962− 3: keyword.generator.asterisk.tsx
1966− - include: method-declaration-name
1969− - include: object-literal-method-declaration
1972− - meta_scope: meta.object.member.tsx meta.object-literal.key.tsx
1973− - match: '(?=:)|((?<=[\]])(?=\s*[\(\<]))'
1976− - include: array-literal
1977− - match: '(?=[\''\"\`])'
1979− - meta_scope: meta.object.member.tsx meta.object-literal.key.tsx
1980− - match: '(?=:)|((?<=[\''\"\`])(?=((\s*[\(\<,}])|(\s+(as)\s+))))'
1985− (?x)(?=(\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?:
1986− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3
1987− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3
1988− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3
1989− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3
1990− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1
1991− (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.
1992− (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1
1993− (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1
1996− - meta_scope: meta.object.member.tsx meta.object-literal.key.tsx
1997− - match: '(?=:)|(?=\s*([\(\<,}])|(\s+as\s+))'
2000− - include: numeric-literal
2001− - match: '(?<=[\]\''\"\`])(?=\s*[\(\<])'
2003− - meta_scope: meta.method.declaration.tsx
2004− - match: '(?=\}|;|,)|(?<=\})'
2006− - include: function-body
2007− - match: '(?![_$[:alpha:]])([[:digit:]]+)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:)'
2008− scope: meta.object.member.tsx
2010− 0: meta.object-literal.key.tsx
2011− 1: constant.numeric.decimal.tsx
2013− (?x)(?:([_$[:alpha:]][_$[:alnum:]]*)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:(\s*\/\*([^\*]|(\*[^\/]))*\*\/)*\s*(
2015− (function\s*[(<*]) |
2017− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
2020− ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
2021− # sure shot arrow functions even if => is on new line
2023− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
2024− [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
2027− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:
2031− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
2033− # arrow function possible to detect only with => on same line
2035− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters
2036− \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters
2037− (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type
2038− \s*=> # arrow operator
2042− scope: meta.object.member.tsx
2044− 0: meta.object-literal.key.tsx
2045− 1: entity.name.function.tsx
2046− - match: '(?:[_$[:alpha:]][_$[:alnum:]]*)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:)'
2047− scope: meta.object.member.tsx
2049− 0: meta.object-literal.key.tsx
2052− 0: keyword.operator.spread.tsx
2054− - meta_scope: meta.object.member.tsx
2055− - match: '(?=,|\})'
2057− - include: expression
2058− - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?=,|\}|$|\/\/|\/\*)'
2059− scope: meta.object.member.tsx
2061− 1: variable.other.readwrite.tsx
2062− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+(const)(?=\s*([,}]|$))'
2063− scope: meta.object.member.tsx
2065− 1: keyword.control.as.tsx
2066− 2: storage.modifier.tsx
2067− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+'
2069− 1: keyword.control.as.tsx
2071− - meta_scope: meta.object.member.tsx
2072− - match: '(?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|^|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+))'
2075− - match: '(?=[_$[:alpha:]][_$[:alnum:]]*\s*=)'
2077− - meta_scope: meta.object.member.tsx
2078− - match: '(?=,|\}|$|\/\/|\/\*)'
2080− - include: expression
2083− 0: meta.object-literal.key.tsx punctuation.separator.key-value.tsx
2085− - meta_scope: meta.object.member.tsx
2086− - match: '(?=,|\})'
2088− - match: '(?<=:)\s*(async)?(?=\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'
2090− 1: storage.modifier.async.tsx
2094− - include: type-parameters
2097− 0: meta.brace.round.tsx
2101− 0: meta.brace.round.tsx
2103− - include: expression-inside-possibly-arrow-parens
2104− - match: '(?<=:)\s*(async)?\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'
2106− 1: storage.modifier.async.tsx
2107− 2: meta.brace.round.tsx
2111− 0: meta.brace.round.tsx
2113− - include: expression-inside-possibly-arrow-parens
2114− - match: (?<=:)\s*(async)?\s*(?=\<\s*$)
2116− 1: storage.modifier.async.tsx
2120− - include: type-parameters
2121− - match: '(?<=\>)\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'
2123− 1: meta.brace.round.tsx
2127− 0: meta.brace.round.tsx
2129− - include: expression-inside-possibly-arrow-parens
2130− - include: possibly-arrow-return-type
2131− - include: expression
2132− - include: punctuation-comma
2133− parameter-array-binding-pattern:
2134− - match: '(?:(\.\.\.)\s*)?(\[)'
2136− 1: keyword.operator.rest.tsx
2137− 2: punctuation.definition.binding-pattern.array.tsx
2141− 0: punctuation.definition.binding-pattern.array.tsx
2143− - include: parameter-binding-element
2144− - include: punctuation-comma
2145− parameter-binding-element:
2148− - include: numeric-literal
2150− - include: parameter-object-binding-pattern
2151− - include: parameter-array-binding-pattern
2152− - include: destructuring-parameter-rest
2153− - include: variable-initializer
2155− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|protected|private|readonly)\s+(?=(override|public|protected|private|readonly)\s+)'
2157− 1: storage.modifier.tsx
2159− (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s*
2160− # function assignment |
2163− (function\s*[(<*]) |
2165− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
2168− ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
2169− # sure shot arrow functions even if => is on new line
2171− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
2172− [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
2175− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:
2179− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
2181− # arrow function possible to detect only with => on same line
2183− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters
2184− \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters
2185− (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type
2186− \s*=> # arrow operator
2190− # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) =>
2196− ([_$[:alnum:]]+\s*(
2202− (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |
2203− (:\s*((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
2204− (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
2206− (function\s*[(<*]) |
2208− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
2211− ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
2212− # sure shot arrow functions even if => is on new line
2214− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
2215− [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
2218− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:
2222− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
2224− # arrow function possible to detect only with => on same line
2226− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters
2227− \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters
2228− (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type
2229− \s*=> # arrow operator
2234− 1: storage.modifier.tsx
2235− 2: keyword.operator.rest.tsx
2236− 3: entity.name.function.tsx variable.language.this.tsx
2237− 4: entity.name.function.tsx
2238− 5: keyword.operator.optional.tsx
2239− - match: '(?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)'
2241− 1: storage.modifier.tsx
2242− 2: keyword.operator.rest.tsx
2243− 3: variable.parameter.tsx variable.language.this.tsx
2244− 4: variable.parameter.tsx
2245− 5: keyword.operator.optional.tsx
2246− parameter-object-binding-element:
2249− (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?:
2250− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3
2251− (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3
2252− (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3
2253− (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3
2254− (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1
2255− (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1.
2256− (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1
2257− (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1
2258− )(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:))
2260− - match: '(?=,|\})'
2262− - include: object-binding-element-propertyName
2263− - include: parameter-binding-element
2264− - include: parameter-object-binding-pattern
2265− - include: destructuring-parameter-rest
2266− - include: variable-initializer
2267− - include: punctuation-comma
2268− parameter-object-binding-pattern:
2269− - match: '(?:(\.\.\.)\s*)?(\{)'
2271− 1: keyword.operator.rest.tsx
2272− 2: punctuation.definition.binding-pattern.object.tsx
2276− 0: punctuation.definition.binding-pattern.object.tsx
2278− - include: parameter-object-binding-element
2279− parameter-type-annotation:
2282− 1: keyword.operator.type.annotation.tsx
2284− - meta_scope: meta.type.annotation.tsx
2285− - match: "(?=[,)])|(?==[^>])"
2291− 0: meta.brace.round.tsx
2295− 0: meta.brace.round.tsx
2297− - include: expression
2298− paren-expression-possibly-arrow:
2299− - match: '(?<=[(=,])\s*(async)?(?=\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))'
2301− 1: storage.modifier.async.tsx
2305− - include: paren-expression-possibly-arrow-with-typeparameters
2306− - match: '(?<=[(=,]|=>|^return|[^\._$[:alnum:]]return)\s*(async)?(?=\s*((((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\()|(<))\s*$)'
2308− 1: storage.modifier.async.tsx
2312− - include: paren-expression-possibly-arrow-with-typeparameters
2313− - include: possibly-arrow-return-type
2314− paren-expression-possibly-arrow-with-typeparameters:
2315− - include: type-parameters
2318− 0: meta.brace.round.tsx
2322− 0: meta.brace.round.tsx
2324− - include: expression-inside-possibly-arrow-parens
2325− possibly-arrow-return-type:
2326− - match: '(?<=\)|^)\s*(:)(?=\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*=>)'
2328− 1: meta.arrow.tsx meta.return.type.arrow.tsx keyword.operator.type.annotation.tsx
2330− - meta_content_scope: meta.arrow.tsx meta.return.type.arrow.tsx
2331− - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))'
2333− - include: arrow-return-type-body
2335− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(get|set)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
2336− scope: storage.type.property.tsx
2337− punctuation-accessor:
2338− - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))'
2340− 1: punctuation.accessor.tsx
2341− 2: punctuation.accessor.optional.tsx
2344− scope: punctuation.separator.comma.tsx
2345− punctuation-semicolon:
2347− scope: punctuation.terminator.statement.tsx
2351− 0: punctuation.definition.string.begin.tsx
2353− - meta_scope: string.quoted.double.tsx
2354− - match: '(")|((?:[^\\\n])$)'
2356− 1: punctuation.definition.string.end.tsx
2357− 2: invalid.illegal.newline.tsx
2359− - include: string-character-escape
2363− 0: punctuation.definition.string.begin.tsx
2365− - meta_scope: string.quoted.single.tsx
2366− - match: '(\'')|((?:[^\\\n])$)'
2368− 1: punctuation.definition.string.end.tsx
2369− 2: invalid.illegal.newline.tsx
2371− - include: string-character-escape
2373− - match: '(?<!\+\+|--|})(?<=[=(:,\[?+!]|^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[\()]|\\.|\[([^\]\\]|\\.)+\]|\(([^\)\\]|\\.)+\))+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'
2375− 1: punctuation.definition.string.begin.tsx
2377− - meta_scope: string.regexp.tsx
2378− - match: "(/)([dgimsuy]*)"
2380− 1: punctuation.definition.string.end.tsx
2381− 2: keyword.other.tsx
2384− - match: '((?<![_$[:alnum:])\]]|\+\+|--|}|\*\/)|((?<=^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case))\s*)\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))'
2386− 0: punctuation.definition.string.begin.tsx
2388− - meta_scope: string.regexp.tsx
2389− - match: "(/)([dgimsuy]*)"
2391− 1: punctuation.definition.string.end.tsx
2392− 2: keyword.other.tsx
2395− regex-character-class:
2396− - match: '\\[wWsSdDtrnvf]|\.'
2397− scope: constant.other.character-class.regexp
2398− - match: '\\([0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4})'
2399− scope: constant.character.numeric.regexp
2400− - match: '\\c[A-Z]'
2401− scope: constant.character.control.regexp
2403− scope: constant.character.escape.backslash.regexp
2405− - match: '\\[bB]|\^|\$'
2406− scope: keyword.control.anchor.regexp
2407− - match: '\\[1-9]\d*|\\k<([a-zA-Z_$][\w$]*)>'
2409− 0: keyword.other.back-reference.regexp
2410− 1: variable.other.regexp
2411− - match: '[?+*]|\{(\d+,\d+|\d+,|,\d+|\d+)\}\??'
2412− scope: keyword.operator.quantifier.regexp
2414− scope: keyword.operator.or.regexp
2415− - match: (\()((\?=)|(\?!)|(\?<=)|(\?<!))
2417− 1: punctuation.definition.group.regexp
2418− 2: punctuation.definition.group.assertion.regexp
2419− 3: meta.assertion.look-ahead.regexp
2420− 4: meta.assertion.negative-look-ahead.regexp
2421− 5: meta.assertion.look-behind.regexp
2422− 6: meta.assertion.negative-look-behind.regexp
2424− - meta_scope: meta.group.assertion.regexp
2427− 1: punctuation.definition.group.regexp
2430− - match: '\((?:(\?:)|(?:\?<([a-zA-Z_$][\w$]*)>))?'
2432− 0: punctuation.definition.group.regexp
2433− 1: punctuation.definition.group.no-capture.regexp
2434− 2: variable.other.regexp
2436− - meta_scope: meta.group.regexp
2439− 0: punctuation.definition.group.regexp
2442− - match: '(\[)(\^)?'
2444− 1: punctuation.definition.character-class.regexp
2445− 2: keyword.operator.negation.regexp
2447− - meta_scope: constant.other.character-class.set.regexp
2450− 1: punctuation.definition.character-class.regexp
2452− - 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])|(\\.))'
2453− scope: constant.other.character-class.range.regexp
2455− 1: constant.character.numeric.regexp
2456− 2: constant.character.control.regexp
2457− 3: constant.character.escape.backslash.regexp
2458− 4: constant.character.numeric.regexp
2459− 5: constant.character.control.regexp
2460− 6: constant.character.escape.backslash.regexp
2461− - include: regex-character-class
2462− - include: regex-character-class
2464− - match: (?<=\))\s*(:)(?=\s*\S)
2466− 1: keyword.operator.type.annotation.tsx
2468− - meta_scope: meta.return.type.tsx
2469− - match: "(?<![:|&])(?=$|^|[{};,]|//)"
2471− - include: return-type-core
2472− - match: (?<=\))\s*(:)
2474− 1: keyword.operator.type.annotation.tsx
2476− - meta_scope: meta.return.type.tsx
2477− - match: '(?<![:|&])((?=[{};,]|//|^\s*$)|((?<=\S)(?=\s*$)))'
2479− - include: return-type-core
2482− - match: '(?<=[:|&])(?=\s*\{)'
2486− - include: type-object
2487− - include: type-predicate-operator
2490− - match: \A(#!).*(?=$)
2491− scope: comment.line.shebang.tsx
2493− 1: punctuation.definition.comment.tsx
2494− single-line-comment-consuming-line-ending:
2495− - match: '(^[ \t]+)?((//)(?:\s*((@)internal)(?=\s|$))?)'
2497− 1: punctuation.whitespace.comment.leading.tsx
2498− 2: comment.line.double-slash.tsx
2499− 3: punctuation.definition.comment.tsx
2500− 4: storage.type.internaldeclaration.tsx
2501− 5: punctuation.decorator.internaldeclaration.tsx
2503− - meta_content_scope: comment.line.double-slash.tsx
2507− - include: declaration
2508− - include: control-statement
2509− - include: after-operator-block-as-object-literal
2510− - include: decl-block
2512− - include: expression
2513− - include: punctuation-semicolon
2517− - include: qstring-single
2518− - include: qstring-double
2519− - include: template
2520− string-character-escape:
2521− - match: '\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\{[0-9A-Fa-f]+\}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)'
2522− scope: constant.character.escape.tsx
2524− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))super\b(?!\$)'
2525− scope: variable.language.super.tsx
2526− support-function-call-identifiers:
2528− - include: support-objects
2529− - include: object-identifiers
2530− - include: punctuation-accessor
2531− - match: '(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*[\(]\s*[\"\''\`]))'
2532− scope: keyword.operator.expression.import.tsx
2534− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(arguments)\b(?!\$)'
2535− scope: variable.language.arguments.tsx
2537− (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Array|ArrayBuffer|Atomics|BigInt|BigInt64Array|BigUint64Array|Boolean|DataView|Date|Float32Array
2538− |Float64Array|Function|Generator|GeneratorFunction|Int8Array|Int16Array|Int32Array|Intl|Map|Number|Object|Proxy
2539− |Reflect|RegExp|Set|SharedArrayBuffer|SIMD|String|Symbol|TypedArray
2540− |Uint8Array|Uint16Array|Uint32Array|Uint8ClampedArray|WeakMap|WeakSet)\b(?!\$)
2541− scope: support.class.builtin.tsx
2542− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))((Eval|Internal|Range|Reference|Syntax|Type|URI)?Error)\b(?!\$)'
2543− scope: support.class.error.tsx
2544− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Promise)\b(?!\$)'
2545− scope: support.class.promise.tsx
2547− (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(clear(Interval|Timeout)|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval|
2548− isFinite|isNaN|parseFloat|parseInt|require|set(Interval|Timeout)|super|unescape|uneval)(?=\s*\()
2549− scope: support.function.tsx
2551− (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Math)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(?:
2552− (abs|acos|acosh|asin|asinh|atan|atan2|atanh|cbrt|ceil|clz32|cos|cosh|exp|
2553− expm1|floor|fround|hypot|imul|log|log10|log1p|log2|max|min|pow|random|
2554− round|sign|sin|sinh|sqrt|tan|tanh|trunc)
2556− (E|LN10|LN2|LOG10E|LOG2E|PI|SQRT1_2|SQRT2)))?\b(?!\$)
2558− 1: support.constant.math.tsx
2559− 2: punctuation.accessor.tsx
2560− 3: punctuation.accessor.optional.tsx
2561− 4: support.function.math.tsx
2562− 5: support.constant.property.math.tsx
2564− (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(console)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(
2565− assert|clear|count|debug|dir|error|group|groupCollapsed|groupEnd|info|log
2566− |profile|profileEnd|table|time|timeEnd|timeStamp|trace|warn))?\b(?!\$)
2568− 1: support.class.console.tsx
2569− 2: punctuation.accessor.tsx
2570− 3: punctuation.accessor.optional.tsx
2571− 4: support.function.console.tsx
2572− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(JSON)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(parse|stringify))?\b(?!\$)'
2574− 1: support.constant.json.tsx
2575− 2: punctuation.accessor.tsx
2576− 3: punctuation.accessor.optional.tsx
2577− 4: support.function.json.tsx
2578− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(import)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(meta)\b(?!\$)'
2580− 1: keyword.control.import.tsx
2581− 2: punctuation.accessor.tsx
2582− 3: punctuation.accessor.optional.tsx
2583− 4: support.variable.property.importmeta.tsx
2584− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(target)\b(?!\$)'
2586− 1: keyword.operator.new.tsx
2587− 2: punctuation.accessor.tsx
2588− 3: punctuation.accessor.optional.tsx
2589− 4: support.variable.property.target.tsx
2591− (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?:
2592− (?:(constructor|length|prototype|__proto__)\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\())
2594− (?:(EPSILON|MAX_SAFE_INTEGER|MAX_VALUE|MIN_SAFE_INTEGER|MIN_VALUE|NEGATIVE_INFINITY|POSITIVE_INFINITY)\b(?!\$)))
2596− 1: punctuation.accessor.tsx
2597− 2: punctuation.accessor.optional.tsx
2598− 3: support.variable.property.tsx
2599− 4: support.constant.tsx
2601− (?x) (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.)) \b (?:
2602− (document|event|navigator|performance|screen|window)
2604− (AnalyserNode|ArrayBufferView|Attr|AudioBuffer|AudioBufferSourceNode|AudioContext|AudioDestinationNode|AudioListener
2605− |AudioNode|AudioParam|BatteryManager|BeforeUnloadEvent|BiquadFilterNode|Blob|BufferSource|ByteString|CSS|CSSConditionRule
2606− |CSSCounterStyleRule|CSSGroupingRule|CSSMatrix|CSSMediaRule|CSSPageRule|CSSPrimitiveValue|CSSRule|CSSRuleList|CSSStyleDeclaration
2607− |CSSStyleRule|CSSStyleSheet|CSSSupportsRule|CSSValue|CSSValueList|CanvasGradient|CanvasImageSource|CanvasPattern
2608− |CanvasRenderingContext2D|ChannelMergerNode|ChannelSplitterNode|CharacterData|ChromeWorker|CloseEvent|Comment|CompositionEvent
2609− |Console|ConvolverNode|Coordinates|Credential|CredentialsContainer|Crypto|CryptoKey|CustomEvent|DOMError|DOMException
2610− |DOMHighResTimeStamp|DOMImplementation|DOMString|DOMStringList|DOMStringMap|DOMTimeStamp|DOMTokenList|DataTransfer
2611− |DataTransferItem|DataTransferItemList|DedicatedWorkerGlobalScope|DelayNode|DeviceProximityEvent|DirectoryEntry
2612− |DirectoryEntrySync|DirectoryReader|DirectoryReaderSync|Document|DocumentFragment|DocumentTouch|DocumentType|DragEvent
2613− |DynamicsCompressorNode|Element|Entry|EntrySync|ErrorEvent|Event|EventListener|EventSource|EventTarget|FederatedCredential
2614− |FetchEvent|File|FileEntry|FileEntrySync|FileException|FileList|FileReader|FileReaderSync|FileSystem|FileSystemSync
2615− |FontFace|FormData|GainNode|Gamepad|GamepadButton|GamepadEvent|Geolocation|GlobalEventHandlers|HTMLAnchorElement
2616− |HTMLAreaElement|HTMLAudioElement|HTMLBRElement|HTMLBaseElement|HTMLBodyElement|HTMLButtonElement|HTMLCanvasElement
2617− |HTMLCollection|HTMLContentElement|HTMLDListElement|HTMLDataElement|HTMLDataListElement|HTMLDialogElement|HTMLDivElement
2618− |HTMLDocument|HTMLElement|HTMLEmbedElement|HTMLFieldSetElement|HTMLFontElement|HTMLFormControlsCollection|HTMLFormElement
2619− |HTMLHRElement|HTMLHeadElement|HTMLHeadingElement|HTMLHtmlElement|HTMLIFrameElement|HTMLImageElement|HTMLInputElement
2620− |HTMLKeygenElement|HTMLLIElement|HTMLLabelElement|HTMLLegendElement|HTMLLinkElement|HTMLMapElement|HTMLMediaElement
2621− |HTMLMetaElement|HTMLMeterElement|HTMLModElement|HTMLOListElement|HTMLObjectElement|HTMLOptGroupElement|HTMLOptionElement
2622− |HTMLOptionsCollection|HTMLOutputElement|HTMLParagraphElement|HTMLParamElement|HTMLPreElement|HTMLProgressElement
2623− |HTMLQuoteElement|HTMLScriptElement|HTMLSelectElement|HTMLShadowElement|HTMLSourceElement|HTMLSpanElement|HTMLStyleElement
2624− |HTMLTableCaptionElement|HTMLTableCellElement|HTMLTableColElement|HTMLTableDataCellElement|HTMLTableElement|HTMLTableHeaderCellElement
2625− |HTMLTableRowElement|HTMLTableSectionElement|HTMLTextAreaElement|HTMLTimeElement|HTMLTitleElement|HTMLTrackElement
2626− |HTMLUListElement|HTMLUnknownElement|HTMLVideoElement|HashChangeEvent|History|IDBCursor|IDBCursorWithValue|IDBDatabase
2627− |IDBEnvironment|IDBFactory|IDBIndex|IDBKeyRange|IDBMutableFile|IDBObjectStore|IDBOpenDBRequest|IDBRequest|IDBTransaction
2628− |IDBVersionChangeEvent|IIRFilterNode|IdentityManager|ImageBitmap|ImageBitmapFactories|ImageData|Index|InputDeviceCapabilities
2629− |InputEvent|InstallEvent|InstallTrigger|KeyboardEvent|LinkStyle|LocalFileSystem|LocalFileSystemSync|Location|MIDIAccess
2630− |MIDIConnectionEvent|MIDIInput|MIDIInputMap|MIDIOutputMap|MediaElementAudioSourceNode|MediaError|MediaKeyMessageEvent
2631− |MediaKeySession|MediaKeyStatusMap|MediaKeySystemAccess|MediaKeySystemConfiguration|MediaKeys|MediaRecorder|MediaStream
2632− |MediaStreamAudioDestinationNode|MediaStreamAudioSourceNode|MessageChannel|MessageEvent|MessagePort|MouseEvent
2633− |MutationObserver|MutationRecord|NamedNodeMap|Navigator|NavigatorConcurrentHardware|NavigatorGeolocation|NavigatorID
2634− |NavigatorLanguage|NavigatorOnLine|Node|NodeFilter|NodeIterator|NodeList|NonDocumentTypeChildNode|Notification
2635− |OfflineAudioCompletionEvent|OfflineAudioContext|OscillatorNode|PageTransitionEvent|PannerNode|ParentNode|PasswordCredential
2636− |Path2D|PaymentAddress|PaymentRequest|PaymentResponse|Performance|PerformanceEntry|PerformanceFrameTiming|PerformanceMark
2637− |PerformanceMeasure|PerformanceNavigation|PerformanceNavigationTiming|PerformanceObserver|PerformanceObserverEntryList
2638− |PerformanceResourceTiming|PerformanceTiming|PeriodicSyncEvent|PeriodicWave|Plugin|Point|PointerEvent|PopStateEvent
2639− |PortCollection|Position|PositionError|PositionOptions|PresentationConnectionClosedEvent|PresentationConnectionList
2640− |PresentationReceiver|ProcessingInstruction|ProgressEvent|PromiseRejectionEvent|PushEvent|PushRegistrationManager
2641− |RTCCertificate|RTCConfiguration|RTCPeerConnection|RTCSessionDescriptionCallback|RTCStatsReport|RadioNodeList|RandomSource
2642− |Range|ReadableByteStream|RenderingContext|SVGAElement|SVGAngle|SVGAnimateColorElement|SVGAnimateElement|SVGAnimateMotionElement
2643− |SVGAnimateTransformElement|SVGAnimatedAngle|SVGAnimatedBoolean|SVGAnimatedEnumeration|SVGAnimatedInteger|SVGAnimatedLength
2644− |SVGAnimatedLengthList|SVGAnimatedNumber|SVGAnimatedNumberList|SVGAnimatedPoints|SVGAnimatedPreserveAspectRatio
2645− |SVGAnimatedRect|SVGAnimatedString|SVGAnimatedTransformList|SVGAnimationElement|SVGCircleElement|SVGClipPathElement
2646− |SVGCursorElement|SVGDefsElement|SVGDescElement|SVGElement|SVGEllipseElement|SVGEvent|SVGFilterElement|SVGFontElement
2647− |SVGFontFaceElement|SVGFontFaceFormatElement|SVGFontFaceNameElement|SVGFontFaceSrcElement|SVGFontFaceUriElement
2648− |SVGForeignObjectElement|SVGGElement|SVGGlyphElement|SVGGradientElement|SVGHKernElement|SVGImageElement|SVGLength
2649− |SVGLengthList|SVGLineElement|SVGLinearGradientElement|SVGMPathElement|SVGMaskElement|SVGMatrix|SVGMissingGlyphElement
2650− |SVGNumber|SVGNumberList|SVGPathElement|SVGPatternElement|SVGPoint|SVGPolygonElement|SVGPolylineElement|SVGPreserveAspectRatio
2651− |SVGRadialGradientElement|SVGRect|SVGRectElement|SVGSVGElement|SVGScriptElement|SVGSetElement|SVGStopElement|SVGStringList
2652− |SVGStylable|SVGStyleElement|SVGSwitchElement|SVGSymbolElement|SVGTRefElement|SVGTSpanElement|SVGTests|SVGTextElement
2653− |SVGTextPositioningElement|SVGTitleElement|SVGTransform|SVGTransformList|SVGTransformable|SVGUseElement|SVGVKernElement
2654− |SVGViewElement|ServiceWorker|ServiceWorkerContainer|ServiceWorkerGlobalScope|ServiceWorkerRegistration|ServiceWorkerState
2655− |ShadowRoot|SharedWorker|SharedWorkerGlobalScope|SourceBufferList|StereoPannerNode|Storage|StorageEvent|StyleSheet
2656− |StyleSheetList|SubtleCrypto|SyncEvent|Text|TextMetrics|TimeEvent|TimeRanges|Touch|TouchEvent|TouchList|Transferable
2657− |TreeWalker|UIEvent|USVString|VRDisplayCapabilities|ValidityState|WaveShaperNode|WebGL|WebGLActiveInfo|WebGLBuffer
2658− |WebGLContextEvent|WebGLFramebuffer|WebGLProgram|WebGLRenderbuffer|WebGLRenderingContext|WebGLShader|WebGLShaderPrecisionFormat
2659− |WebGLTexture|WebGLTimerQueryEXT|WebGLTransformFeedback|WebGLUniformLocation|WebGLVertexArrayObject|WebGLVertexArrayObjectOES
2660− |WebSocket|WebSockets|WebVTT|WheelEvent|Window|WindowBase64|WindowEventHandlers|WindowTimers|Worker|WorkerGlobalScope
2661− |WorkerLocation|WorkerNavigator|XMLHttpRequest|XMLHttpRequestEventTarget|XMLSerializer|XPathExpression|XPathResult
2662− |XSLTProcessor))\b(?!\$)
2664− 1: support.variable.dom.tsx
2665− 2: support.class.dom.tsx
2667− (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?:
2668− (ATTRIBUTE_NODE|CDATA_SECTION_NODE|COMMENT_NODE|DOCUMENT_FRAGMENT_NODE|DOCUMENT_NODE|DOCUMENT_TYPE_NODE
2669− |DOMSTRING_SIZE_ERR|ELEMENT_NODE|ENTITY_NODE|ENTITY_REFERENCE_NODE|HIERARCHY_REQUEST_ERR|INDEX_SIZE_ERR
2670− |INUSE_ATTRIBUTE_ERR|INVALID_CHARACTER_ERR|NO_DATA_ALLOWED_ERR|NO_MODIFICATION_ALLOWED_ERR|NOT_FOUND_ERR
2671− |NOT_SUPPORTED_ERR|NOTATION_NODE|PROCESSING_INSTRUCTION_NODE|TEXT_NODE|WRONG_DOCUMENT_ERR)
2673− (_content|[xyz]|abbr|above|accept|acceptCharset|accessKey|action|align|[av]Link(?:color)?|all|alt|anchors|appCodeName
2674− |appCore|applets|appMinorVersion|appName|appVersion|archive|areas|arguments|attributes|availHeight|availLeft|availTop
2675− |availWidth|axis|background|backgroundColor|backgroundImage|below|bgColor|body|border|borderBottomWidth|borderColor
2676− |borderLeftWidth|borderRightWidth|borderStyle|borderTopWidth|borderWidth|bottom|bufferDepth|callee|caller|caption
2677− |cellPadding|cells|cellSpacing|ch|characterSet|charset|checked|childNodes|chOff|cite|classes|className|clear
2678− |clientInformation|clip|clipBoardData|closed|code|codeBase|codeType|color|colorDepth|cols|colSpan|compact|complete
2679− |components|content|controllers|cookie|cookieEnabled|cords|cpuClass|crypto|current|data|dateTime|declare|defaultCharset
2680− |defaultChecked|defaultSelected|defaultStatus|defaultValue|defaultView|defer|description|dialogArguments|dialogHeight
2681− |dialogLeft|dialogTop|dialogWidth|dir|directories|disabled|display|docmain|doctype|documentElement|elements|embeds
2682− |enabledPlugin|encoding|enctype|entities|event|expando|external|face|fgColor|filename|firstChild|fontFamily|fontSize
2683− |fontWeight|form|formName|forms|frame|frameBorder|frameElement|frames|hasFocus|hash|headers|height|history|host
2684− |hostname|href|hreflang|hspace|htmlFor|httpEquiv|id|ids|ignoreCase|images|implementation|index|innerHeight|innerWidth
2685− |input|isMap|label|lang|language|lastChild|lastIndex|lastMatch|lastModified|lastParen|layer[sXY]|left|leftContext
2686− |lineHeight|link|linkColor|links|listStyleType|localName|location|locationbar|longDesc|lowsrc|lowSrc|marginBottom
2687− |marginHeight|marginLeft|marginRight|marginTop|marginWidth|maxLength|media|menubar|method|mimeTypes|multiline|multiple
2688− |name|nameProp|namespaces|namespaceURI|next|nextSibling|nodeName|nodeType|nodeValue|noHref|noResize|noShade|notationName
2689− |notations|noWrap|object|offscreenBuffering|onLine|onreadystatechange|opener|opsProfile|options|oscpu|outerHeight
2690− |outerWidth|ownerDocument|paddingBottom|paddingLeft|paddingRight|paddingTop|page[XY]|page[XY]Offset|parent|parentLayer
2691− |parentNode|parentWindow|pathname|personalbar|pixelDepth|pkcs11|platform|plugins|port|prefix|previous|previousDibling
2692− |product|productSub|profile|profileend|prompt|prompter|protocol|publicId|readOnly|readyState|referrer|rel|responseText
2693− |responseXML|rev|right|rightContext|rowIndex|rows|rowSpan|rules|scheme|scope|screen[XY]|screenLeft|screenTop|scripts
2694− |scrollbars|scrolling|sectionRowIndex|security|securityPolicy|selected|selectedIndex|selection|self|shape|siblingAbove
2695− |siblingBelow|size|source|specified|standby|start|status|statusbar|statusText|style|styleSheets|suffixes|summary
2696− |systemId|systemLanguage|tagName|tags|target|tBodies|text|textAlign|textDecoration|textIndent|textTransform|tFoot|tHead
2697− |title|toolbar|top|type|undefined|uniqueID|updateInterval|URL|URLUnencoded|useMap|userAgent|userLanguage|userProfile
2698− |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\()
2700− 1: punctuation.accessor.tsx
2701− 2: punctuation.accessor.optional.tsx
2702− 3: support.constant.dom.tsx
2703− 4: support.variable.property.dom.tsx
2705− (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Buffer|EventEmitter|Server|Pipe|Socket|REPLServer|ReadStream|WriteStream|Stream
2706− |Inflate|Deflate|InflateRaw|DeflateRaw|GZip|GUnzip|Unzip|Zip)\b(?!\$)
2707− scope: support.class.node.tsx
2709− (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(process)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))(?:
2710− (arch|argv|config|connected|env|execArgv|execPath|exitCode|mainModule|pid|platform|release|stderr|stdin|stdout|title|version|versions)
2712− (abort|chdir|cwd|disconnect|exit|[sg]ete?[gu]id|send|[sg]etgroups|initgroups|kill|memoryUsage|nextTick|umask|uptime|hrtime)
2715− 1: support.variable.object.process.tsx
2716− 2: punctuation.accessor.tsx
2717− 3: punctuation.accessor.optional.tsx
2718− 4: support.variable.property.process.tsx
2719− 5: support.function.process.tsx
2720− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(exports)|(module)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))(exports|id|filename|loaded|parent|children))?)\b(?!\$)'
2722− 1: support.type.object.module.tsx
2723− 2: support.type.object.module.tsx
2724− 3: punctuation.accessor.tsx
2725− 4: punctuation.accessor.optional.tsx
2726− 5: support.type.object.module.tsx
2727− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(global|GLOBAL|root|__dirname|__filename)\b(?!\$)'
2728− scope: support.variable.object.node.tsx
2730− (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s*
2732− (on(?:Rowsinserted|Rowsdelete|Rowenter|Rowexit|Resize|Resizestart|Resizeend|Reset|
2733− Readystatechange|Mouseout|Mouseover|Mousedown|Mouseup|Mousemove|
2734− Before(?:cut|deactivate|unload|update|paste|print|editfocus|activate)|
2735− Blur|Scrolltop|Submit|Select|Selectstart|Selectionchange|Hover|Help|
2736− Change|Contextmenu|Controlselect|Cut|Cellchange|Clock|Close|Deactivate|
2737− Datasetchanged|Datasetcomplete|Dataavailable|Drop|Drag|Dragstart|Dragover|
2738− Dragdrop|Dragenter|Dragend|Dragleave|Dblclick|Unload|Paste|Propertychange|Error|
2739− Errorupdate|Keydown|Keyup|Keypress|Focus|Load|Activate|Afterupdate|Afterprint|Abort)
2741− (shift|showModelessDialog|showModalDialog|showHelp|scroll|scrollX|scrollByPages|
2742− scrollByLines|scrollY|scrollTo|stop|strike|sizeToContent|sidebar|signText|sort|
2743− sup|sub|substr|substring|splice|split|send|set(?:Milliseconds|Seconds|Minutes|Hours|
2744− Month|Year|FullYear|Date|UTC(?:Milliseconds|Seconds|Minutes|Hours|Month|FullYear|Date)|
2745− Time|Hotkeys|Cursor|ZOptions|Active|Resizable|RequestHeader)|search|slice|
2746− savePreferences|small|home|handleEvent|navigate|char|charCodeAt|charAt|concat|
2747− contextual|confirm|compile|clear|captureEvents|call|createStyleSheet|createPopup|
2748− createEventObject|to(?:GMTString|UTCString|String|Source|UpperCase|LowerCase|LocaleString)|
2749− test|taint|taintEnabled|indexOf|italics|disableExternalCapture|dump|detachEvent|unshift|
2750− untaint|unwatch|updateCommands|join|javaEnabled|pop|push|plugins.refresh|paddings|parse|
2751− print|prompt|preference|enableExternalCapture|exec|execScript|valueOf|UTC|find|file|
2752− fileModifiedDate|fileSize|fileCreatedDate|fileUpdatedDate|fixed|fontsize|fontcolor|
2753− forward|fromCharCode|watch|link|load|lastIndexOf|anchor|attachEvent|atob|apply|alert|
2754− abort|routeEvents|resize|resizeBy|resizeTo|recalc|returnValue|replace|reverse|reload|
2755− releaseCapture|releaseEvents|go|get(?:Milliseconds|Seconds|Minutes|Hours|Month|Day|Year|FullYear|
2756− Time|Date|TimezoneOffset|UTC(?:Milliseconds|Seconds|Minutes|Hours|Day|Month|FullYear|Date)|
2757− Attention|Selection|ResponseHeader|AllResponseHeaders)|moveBy|moveBelow|moveTo|
2758− moveToAbsolute|moveAbove|mergeAttributes|match|margins|btoa|big|bold|borderWidths|blink|back
2760− (acceptNode|add|addEventListener|addTextTrack|adoptNode|after|animate|append|
2761− appendChild|appendData|before|blur|canPlayType|captureStream|
2762− caretPositionFromPoint|caretRangeFromPoint|checkValidity|clear|click|
2763− cloneContents|cloneNode|cloneRange|close|closest|collapse|
2764− compareBoundaryPoints|compareDocumentPosition|comparePoint|contains|
2765− convertPointFromNode|convertQuadFromNode|convertRectFromNode|createAttribute|
2766− createAttributeNS|createCaption|createCDATASection|createComment|
2767− createContextualFragment|createDocument|createDocumentFragment|
2768− createDocumentType|createElement|createElementNS|createEntityReference|
2769− createEvent|createExpression|createHTMLDocument|createNodeIterator|
2770− createNSResolver|createProcessingInstruction|createRange|createShadowRoot|
2771− createTBody|createTextNode|createTFoot|createTHead|createTreeWalker|delete|
2772− deleteCaption|deleteCell|deleteContents|deleteData|deleteRow|deleteTFoot|
2773− deleteTHead|detach|disconnect|dispatchEvent|elementFromPoint|elementsFromPoint|
2774− enableStyleSheetsForSet|entries|evaluate|execCommand|exitFullscreen|
2775− exitPointerLock|expand|extractContents|fastSeek|firstChild|focus|forEach|get|
2776− getAll|getAnimations|getAttribute|getAttributeNames|getAttributeNode|
2777− getAttributeNodeNS|getAttributeNS|getBoundingClientRect|getBoxQuads|
2778− getClientRects|getContext|getDestinationInsertionPoints|getElementById|
2779− getElementsByClassName|getElementsByName|getElementsByTagName|
2780− getElementsByTagNameNS|getItem|getNamedItem|getSelection|getStartDate|
2781− getVideoPlaybackQuality|has|hasAttribute|hasAttributeNS|hasAttributes|
2782− hasChildNodes|hasFeature|hasFocus|importNode|initEvent|insertAdjacentElement|
2783− insertAdjacentHTML|insertAdjacentText|insertBefore|insertCell|insertData|
2784− insertNode|insertRow|intersectsNode|isDefaultNamespace|isEqualNode|
2785− isPointInRange|isSameNode|item|key|keys|lastChild|load|lookupNamespaceURI|
2786− lookupPrefix|matches|move|moveAttribute|moveAttributeNode|moveChild|
2787− moveNamedItem|namedItem|nextNode|nextSibling|normalize|observe|open|
2788− parentNode|pause|play|postMessage|prepend|preventDefault|previousNode|
2789− previousSibling|probablySupportsContext|queryCommandEnabled|
2790− queryCommandIndeterm|queryCommandState|queryCommandSupported|queryCommandValue|
2791− querySelector|querySelectorAll|registerContentHandler|registerElement|
2792− registerProtocolHandler|releaseCapture|releaseEvents|remove|removeAttribute|
2793− removeAttributeNode|removeAttributeNS|removeChild|removeEventListener|
2794− removeItem|replace|replaceChild|replaceData|replaceWith|reportValidity|
2795− requestFullscreen|requestPointerLock|reset|scroll|scrollBy|scrollIntoView|
2796− scrollTo|seekToNextFrame|select|selectNode|selectNodeContents|set|setAttribute|
2797− setAttributeNode|setAttributeNodeNS|setAttributeNS|setCapture|
2798− setCustomValidity|setEnd|setEndAfter|setEndBefore|setItem|setNamedItem|
2799− setRangeText|setSelectionRange|setSinkId|setStart|setStartAfter|setStartBefore|
2800− slice|splitText|stepDown|stepUp|stopImmediatePropagation|stopPropagation|
2801− submit|substringData|supports|surroundContents|takeRecords|terminate|toBlob|
2802− toDataURL|toggle|toString|values|write|writeln
2804− (all|catch|finally|race|reject|resolve|then
2808− 1: punctuation.accessor.tsx
2809− 2: punctuation.accessor.optional.tsx
2810− 3: support.function.event-handler.tsx
2811− 4: support.function.tsx
2812− 5: support.function.dom.tsx
2813− 6: support.function.promise.tsx
2815− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bswitch\s*\()'
2817− - meta_scope: switch-statement.expr.tsx
2820− 0: punctuation.definition.block.tsx
2823− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(switch)\s*(\()'
2825− 1: keyword.control.switch.tsx
2826− 2: meta.brace.round.tsx
2828− - meta_scope: switch-expression.expr.tsx
2831− 0: meta.brace.round.tsx
2833− - include: expression
2836− 0: punctuation.definition.block.tsx
2838− - meta_scope: switch-block.expr.tsx
2841− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default(?=:))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
2843− 1: keyword.control.switch.tsx
2845− - meta_scope: case-clause.expr.tsx
2848− - include: expression
2849− - match: '(:)\s*(\{)'
2851− 1: case-clause.expr.tsx punctuation.definition.section.case-statement.tsx
2852− 2: meta.block.tsx punctuation.definition.block.tsx
2854− - meta_content_scope: meta.block.tsx
2857− 0: meta.block.tsx punctuation.definition.block.tsx
2859− - include: statements
2862− 0: case-clause.expr.tsx punctuation.definition.section.case-statement.tsx
2863− - include: statements
2865− - include: template-call
2866− - match: "([_$[:alpha:]][_$[:alnum:]]*)?(`)"
2868− 1: entity.name.function.tagged-template.tsx
2869− 2: punctuation.definition.string.template.begin.tsx
2871− - meta_scope: string.template.tsx
2874− 0: punctuation.definition.string.template.end.tsx
2876− - include: template-substitution-element
2877− - include: string-character-escape
2879− - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?`)'
2881− - meta_scope: string.template.tsx
2884− - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*))'
2886− - match: '(?=(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?`)'
2888− - include: support-function-call-identifiers
2889− - match: "([_$[:alpha:]][_$[:alnum:]]*)"
2890− scope: entity.name.function.tagged-template.tsx
2891− - include: type-arguments
2892− - match: '([_$[:alpha:]][_$[:alnum:]]*)?\s*(?=(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)`)'
2894− 1: entity.name.function.tagged-template.tsx
2896− - meta_scope: string.template.tsx
2899− - include: type-arguments
2900− template-substitution-element:
2903− 0: punctuation.definition.template-expression.begin.tsx
2905− - meta_scope: meta.template.expression.tsx
2906− - meta_content_scope: meta.embedded.line.tsx
2909− 0: punctuation.definition.template-expression.end.tsx
2911− - include: expression
2913− - include: template-call
2914− - match: "([_$[:alpha:]][_$[:alnum:]]*)?(`)"
2916− 1: entity.name.function.tagged-template.tsx
2917− 2: punctuation.definition.string.template.begin.tsx
2919− - meta_scope: string.template.tsx
2922− 0: punctuation.definition.string.template.end.tsx
2924− - include: template-type-substitution-element
2925− - include: string-character-escape
2926− template-type-substitution-element:
2929− 0: punctuation.definition.template-expression.begin.tsx
2931− - meta_scope: meta.template.expression.tsx
2932− - meta_content_scope: meta.embedded.line.tsx
2935− 0: punctuation.definition.template-expression.end.tsx
2938− ternary-expression:
2939− - match: '(?!\?\.\s*[^[:digit:]])(\?)(?!\?)'
2941− 1: keyword.operator.ternary.tsx
2945− 1: keyword.operator.ternary.tsx
2947− - include: expression
2949− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))this\b(?!\$)'
2950− scope: variable.language.this.tsx
2953− - include: type-string
2954− - include: numeric-literal
2955− - include: type-primitive
2956− - include: type-builtin-literals
2957− - include: type-parameters
2958− - include: type-tuple
2959− - include: type-object
2960− - include: type-conditional
2961− - include: type-operators
2962− - include: type-fn-type-parameters
2963− - include: type-paren-or-function-parameters
2964− - include: type-function-return-type
2965− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*'
2967− 1: storage.modifier.tsx
2968− - include: type-name
2969− type-alias-declaration:
2970− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(type)\b\s+([_$[:alpha:]][_$[:alnum:]]*)\s*'
2972− 1: keyword.control.export.tsx
2973− 2: storage.modifier.tsx
2974− 3: storage.type.type.tsx
2975− 4: entity.name.type.alias.tsx
2977− - meta_scope: meta.type.declaration.tsx
2978− - match: '(?=\}|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
2981− - include: type-parameters
2982− - match: '(=)\s*(intrinsic)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
2984− 1: keyword.operator.assignment.tsx
2985− 2: keyword.control.intrinsic.tsx
2987− - match: '(?=\}|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
2992− 1: keyword.operator.assignment.tsx
2994− - match: '(?=\}|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
2998− - match: (:)(?=\s*\S)
3000− 1: keyword.operator.type.annotation.tsx
3002− - meta_scope: meta.type.annotation.tsx
3003− - match: '(?<![:|&])((?=$|^|[,);\}\]]|//)|(?==[^>])|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)))'
3008− 1: keyword.operator.type.annotation.tsx
3010− - meta_scope: meta.type.annotation.tsx
3011− - match: '(?<![:|&])((?=[,);\}\]]|//)|(?==[^>])|(?=^\s*$)|((?<=\S)(?=\s*$))|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)))'
3017− 0: punctuation.definition.typeparameters.begin.tsx
3019− - meta_scope: meta.type.parameters.tsx
3022− 0: punctuation.definition.typeparameters.end.tsx
3024− - include: type-arguments-body
3025− type-arguments-body:
3026− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(_)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
3028− 0: keyword.operator.type.tsx
3030− - include: punctuation-comma
3031− type-builtin-literals:
3032− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(this|true|false|undefined|null|object)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
3033− scope: support.type.builtin.tsx
3035− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(extends)\s+'
3037− 1: storage.modifier.tsx
3043− 0: keyword.operator.ternary.tsx
3047− 0: keyword.operator.ternary.tsx
3051− type-fn-type-parameters:
3052− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(new)\b(?=\s*\<)'
3054− 1: meta.type.constructor.tsx storage.modifier.tsx
3055− 2: meta.type.constructor.tsx keyword.control.new.tsx
3060− - include: type-parameters
3061− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(new)\b\s*(?=\()'
3063− 1: storage.modifier.tsx
3064− 2: keyword.control.new.tsx
3066− - meta_scope: meta.type.constructor.tsx
3069− - include: function-parameters
3076− ([_$[:alnum:]]+\s*(
3084− - meta_scope: meta.type.function.tsx
3087− - include: function-parameters
3088− type-function-return-type:
3089− - match: (=>)(?=\s*\S)
3091− 1: storage.type.function.arrow.tsx
3093− - meta_scope: meta.type.function.return.tsx
3094− - match: '(?<!=>)(?<![|&])(?=[,\]\)\{\}=;>:\?]|//|$)'
3096− - include: type-function-return-type-core
3099− 0: storage.type.function.arrow.tsx
3101− - meta_scope: meta.type.function.return.tsx
3102− - match: '(?<!=>)(?<![|&])((?=[,\]\)\{\}=;:\?>]|//|^\s*$)|((?<=\S)(?=\s*$)))'
3104− - include: type-function-return-type-core
3105− type-function-return-type-core:
3107− - match: '(?<==>)(?=\s*\{)'
3111− - include: type-object
3112− - include: type-predicate-operator
3115− - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(<)'
3117− 1: entity.name.type.module.tsx
3118− 2: punctuation.accessor.tsx
3119− 3: punctuation.accessor.optional.tsx
3120− 4: meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx
3122− - meta_content_scope: meta.type.parameters.tsx
3125− 1: meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx
3127− - include: type-arguments-body
3128− - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(<)'
3130− 1: entity.name.type.tsx
3131− 2: meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx
3133− - meta_content_scope: meta.type.parameters.tsx
3136− 1: meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx
3138− - include: type-arguments-body
3139− - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))'
3141− 1: entity.name.type.module.tsx
3142− 2: punctuation.accessor.tsx
3143− 3: punctuation.accessor.optional.tsx
3144− - match: "[_$[:alpha:]][_$[:alnum:]]*"
3145− scope: entity.name.type.tsx
3149− 0: punctuation.definition.block.tsx
3151− - meta_scope: meta.object.type.tsx
3154− 0: punctuation.definition.block.tsx
3157− - include: method-declaration
3158− - include: indexer-declaration
3159− - include: indexer-mapped-type-declaration
3160− - include: field-declaration
3161− - include: type-annotation
3164− 0: keyword.operator.spread.tsx
3166− - match: '(?=\}|;|,|$)|(?<=\})'
3169− - include: punctuation-comma
3170− - include: punctuation-semicolon
3173− - include: typeof-operator
3174− - match: '([&|])(?=\s*\{)'
3176− 0: keyword.operator.type.tsx
3180− - include: type-object
3183− 0: keyword.operator.type.tsx
3187− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))keyof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
3188− scope: keyword.operator.expression.keyof.tsx
3190− scope: keyword.operator.ternary.tsx
3191− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))infer(?=\s+[_$[:alpha:]])'
3192− scope: keyword.operator.expression.infer.tsx
3193− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*\()'
3194− scope: keyword.operator.expression.import.tsx
3198− 1: punctuation.definition.typeparameters.begin.tsx
3200− - meta_scope: meta.type.parameters.tsx
3203− 1: punctuation.definition.typeparameters.end.tsx
3206− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(extends)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
3207− scope: storage.modifier.tsx
3209− - include: punctuation-comma
3211− scope: keyword.operator.assignment.tsx
3212− type-paren-or-function-parameters:
3215− 0: meta.brace.round.tsx
3217− - meta_scope: meta.type.paren.cover.tsx
3220− 0: meta.brace.round.tsx
3223− (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))\s*(\??)(?=\s*(:\s*(
3228− ([_$[:alnum:]]+\s*(
3234− (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |
3235− (:\s*((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))))
3237− 1: storage.modifier.tsx
3238− 2: keyword.operator.rest.tsx
3239− 3: entity.name.function.tsx variable.language.this.tsx
3240− 4: entity.name.function.tsx
3241− 5: keyword.operator.optional.tsx
3242− - match: '(?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))\s*(\??)(?=:)'
3244− 1: storage.modifier.tsx
3245− 2: keyword.operator.rest.tsx
3246− 3: variable.parameter.tsx variable.language.this.tsx
3247− 4: variable.parameter.tsx
3248− 5: keyword.operator.optional.tsx
3249− - include: type-annotation
3251− scope: punctuation.separator.parameter.tsx
3253− type-predicate-operator:
3254− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(asserts)\s+)?(?!asserts)(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))\s(is)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
3256− 1: keyword.operator.type.asserts.tsx
3257− 2: variable.parameter.tsx variable.language.this.tsx
3258− 3: variable.parameter.tsx
3259− 4: keyword.operator.expression.is.tsx
3260− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(asserts)\s+(?!is)(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
3262− 1: keyword.operator.type.asserts.tsx
3263− 2: variable.parameter.tsx variable.language.this.tsx
3264− 3: variable.parameter.tsx
3265− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))asserts(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
3266− scope: keyword.operator.type.asserts.tsx
3267− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))is(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
3268− scope: keyword.operator.expression.is.tsx
3270− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(string|number|bigint|boolean|symbol|any|void|never|unknown)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
3271− scope: support.type.primitive.tsx
3273− - include: qstring-single
3274− - include: qstring-double
3275− - include: template-type
3279− 0: meta.brace.square.tsx
3281− - meta_scope: meta.type.tuple.tsx
3284− 0: meta.brace.square.tsx
3287− scope: keyword.operator.rest.tsx
3288− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))([_$[:alpha:]][_$[:alnum:]]*)\s*(\?)?\s*(:)'
3290− 1: entity.name.label.tsx
3291− 2: keyword.operator.optional.tsx
3292− 3: punctuation.separator.label.tsx
3294− - include: punctuation-comma
3296− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))typeof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
3298− 0: keyword.operator.expression.typeof.tsx
3300− - match: '(?=[,);}\]=>:&|{\?]|$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))'
3302− - include: expression
3304− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))undefined(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))'
3305− scope: constant.language.undefined.tsx
3307− - match: '(?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))'
3309− - meta_scope: meta.var.expr.tsx
3310− - match: '(?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))|((?<!^let|[^\._$[:alnum:]]let|^var|[^\._$[:alnum:]]var)(?=\s*$)))'
3312− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*'
3314− 1: keyword.control.export.tsx
3315− 2: storage.modifier.tsx
3316− 3: storage.type.tsx
3320− - include: destructuring-variable
3321− - include: var-single-variable
3322− - include: variable-initializer
3324− - match: (,)\s*((?!\S)|(?=\/\/))
3326− 1: punctuation.separator.comma.tsx
3328− - match: '(?<!,)(((?==|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$)))'
3330− - include: single-line-comment-consuming-line-ending
3332− - include: destructuring-variable
3333− - include: var-single-variable
3334− - include: punctuation-comma
3335− - include: punctuation-comma
3336− - match: '(?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))'
3338− 1: keyword.control.export.tsx
3339− 2: storage.modifier.tsx
3340− 3: storage.type.tsx
3342− - meta_scope: meta.var.expr.tsx
3343− - match: '(?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))|((?<!^const|[^\._$[:alnum:]]const)(?=\s*$)))'
3345− - match: '(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*'
3347− 1: keyword.control.export.tsx
3348− 2: storage.modifier.tsx
3349− 3: storage.type.tsx
3353− - include: destructuring-const
3354− - include: var-single-const
3355− - include: variable-initializer
3357− - match: (,)\s*((?!\S)|(?=\/\/))
3359− 1: punctuation.separator.comma.tsx
3361− - match: '(?<!,)(((?==|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$)))'
3363− - include: single-line-comment-consuming-line-ending
3365− - include: destructuring-const
3366− - include: var-single-const
3367− - include: punctuation-comma
3368− - include: punctuation-comma
3371− (?x)([_$[:alpha:]][_$[:alnum:]]*)(?=\s*
3372− # function assignment |
3375− (function\s*[(<*]) |
3377− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
3380− ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
3381− # sure shot arrow functions even if => is on new line
3383− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
3384− [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
3387− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:
3391− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
3393− # arrow function possible to detect only with => on same line
3395− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters
3396− \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters
3397− (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type
3398− \s*=> # arrow operator
3402− # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) =>
3408− ([_$[:alnum:]]+\s*(
3414− (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |
3415− (:\s*((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
3416− (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
3418− (function\s*[(<*]) |
3420− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
3423− ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
3424− # sure shot arrow functions even if => is on new line
3426− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
3427− [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
3430− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:
3434− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
3436− # arrow function possible to detect only with => on same line
3438− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters
3439− \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters
3440− (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type
3441− \s*=> # arrow operator
3446− 1: meta.definition.variable.tsx variable.other.constant.tsx entity.name.function.tsx
3448− - meta_scope: meta.var-single-variable.expr.tsx
3449− - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'
3451− - include: var-single-variable-type-annotation
3452− - match: "([_$[:alpha:]][_$[:alnum:]]*)"
3454− 1: meta.definition.variable.tsx variable.other.constant.tsx
3456− - meta_scope: meta.var-single-variable.expr.tsx
3457− - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'
3459− - include: var-single-variable-type-annotation
3460− var-single-variable:
3462− (?x)([_$[:alpha:]][_$[:alnum:]]*)(\!)?(?=\s*
3463− # function assignment |
3466− (function\s*[(<*]) |
3468− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
3471− ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
3472− # sure shot arrow functions even if => is on new line
3474− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
3475− [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
3478− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:
3482− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
3484− # arrow function possible to detect only with => on same line
3486− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters
3487− \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters
3488− (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type
3489− \s*=> # arrow operator
3493− # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) =>
3499− ([_$[:alnum:]]+\s*(
3505− (:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) |
3506− (:\s*((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) |
3507− (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*(
3509− (function\s*[(<*]) |
3511− ([_$[:alpha:]][_$[:alnum:]]*\s*=>)
3514− ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) |
3515− # sure shot arrow functions even if => is on new line
3517− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?
3518− [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*
3521− ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param:
3525− [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends
3527− # arrow function possible to detect only with => on same line
3529− (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters
3530− \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters
3531− (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type
3532− \s*=> # arrow operator
3537− 1: meta.definition.variable.tsx entity.name.function.tsx
3538− 2: keyword.operator.definiteassignment.tsx
3540− - meta_scope: meta.var-single-variable.expr.tsx
3541− - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'
3543− - include: var-single-variable-type-annotation
3544− - match: '([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])(\!)?'
3546− 1: meta.definition.variable.tsx variable.other.constant.tsx
3547− 2: keyword.operator.definiteassignment.tsx
3549− - meta_scope: meta.var-single-variable.expr.tsx
3550− - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'
3552− - include: var-single-variable-type-annotation
3553− - match: '([_$[:alpha:]][_$[:alnum:]]*)(\!)?'
3555− 1: meta.definition.variable.tsx variable.other.readwrite.tsx
3556− 2: keyword.operator.definiteassignment.tsx
3558− - meta_scope: meta.var-single-variable.expr.tsx
3559− - match: '(?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'
3561− - include: var-single-variable-type-annotation
3562− var-single-variable-type-annotation:
3563− - include: type-annotation
3566− variable-initializer:
3567− - match: (?<!=|!)(=)(?!=)(?=\s*\S)(?!\s*.*=>\s*$)
3569− 1: keyword.operator.assignment.tsx
3571− - match: '(?=$|^|[,);}\]]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))'
3573− - include: expression
3574− - match: (?<!=|!)(=)(?!=)
3576− 1: keyword.operator.assignment.tsx
3578− - match: '(?=[,);}\]]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))|(?=^\s*$)|(?<=\S)(?<!=)(?=\s*$)'
3580− - include: expression