fileTypes ts name TypeScript patterns include #statements repository access-modifier match (?<!\.|\$)\b(public|protected|private)\b(?!\$) name storage.modifier.ts after-operator-block begin (?<=[=(:,\[?+!]|await|return|yield|throw|in|of|typeof|&&|\|\||\*)\s*(\{) beginCaptures 1 name punctuation.definition.block.ts end \} endCaptures 0 name punctuation.definition.block.ts name meta.object-literal.ts patterns include #object-member array-binding-element patterns include #comment include #object-binding-pattern include #array-binding-pattern match ([_$[:alpha:]][_$[:alnum:]]*) name variable.other.readwrite.ts match , name meta.delimiter.object.comma.ts array-binding-pattern begin \[ beginCaptures 0 name punctuation.definition.binding-pattern.array.ts end \] endCaptures 0 name punctuation.definition.binding-pattern.array.ts patterns include #array-binding-element array-literal begin \[ beginCaptures 0 name meta.brace.square.ts end \] endCaptures 0 name meta.brace.square.ts name meta.array.literal.ts patterns include #expression arrow-function patterns captures 1 name storage.modifier.async.ts match (?<!\.|\$)(\basync)(?=\s*[<(]) name meta.arrow.ts captures 1 name variable.parameter.ts match ([_$[:alpha:]][_$[:alnum:]]*)\s*(?==>) name meta.arrow.ts begin (?x)(?<=return|throw|yield|await|async|[=(\[,:>*])\s*(?=\([^()]*(\([^()]*\))*[^()]*(\([^()]*\))*[^()]*\)(\s*:\s*(.)*)?\s*=>) end (?==>) name meta.arrow.ts patterns include #comment include #function-parameters include #arrow-return-type begin => beginCaptures 0 name storage.type.function.arrow.ts end (?<=\})|((?!\{)(?=\S)) name meta.arrow.ts patterns include #decl-block include #expression arrow-return-type begin (?<=\))\s*: end (?<!:)((?=$)|(?==>|;|//)) name meta.return.type.arrow.ts patterns include #type boolean-literal patterns match (?<!\.|\$)\btrue\b(?!\$) name constant.language.boolean.true.ts match (?<!\.|\$)\bfalse\b(?!\$) name constant.language.boolean.false.ts case-clause begin (?<!\.|\$)\b(case|default(?=:))\b(?!\$) beginCaptures 1 name keyword.control.switch.ts end : name case-clause.expr.ts patterns include #expression cast begin (?:(?<=return|throw|yield|await|[=(,:>*]))\s*(<)(?!<?\=) beginCaptures 1 name meta.brace.angle.ts end > endCaptures 0 name meta.brace.angle.ts name cast.expr.ts patterns include #type class-or-interface-body begin \{ beginCaptures 0 name punctuation.definition.block.ts end \} endCaptures 0 name punctuation.definition.block.ts name meta.object.body.ts patterns include #string include #comment include #decorator include #field-declaration include #method-declaration include #indexer-declaration include #type-annotation include #variable-initializer include #access-modifier include #static-modifier include #property-accessor class-or-interface-declaration begin (?<!\.|\$)\b(?:(export)\s+)?\b(?:(abstract)\s+)?\b(?:(class)|(interface))\b beginCaptures 1 name keyword.control.export.ts 2 name storage.modifier.ts 3 name storage.type.class.ts 4 name storage.type.interface.ts end (?<=\}) endCaptures 1 name punctuation.definition.block.ts name meta.declaration.object.ts patterns include #comment include #class-or-interface-heritage include #class-or-interface-name include #type-parameters include #class-or-interface-body class-or-interface-heritage begin (?<!\.|\$)(?:\b(extends|implements)\b)(?!\$) beginCaptures 1 name storage.modifier.ts end (?=\{) endCaptures 1 name punctuation.definition.block.ts name meta.object.heritage.ts patterns include #comment include #class-or-interface-heritage include #type-parameters include #class-or-interface-heritage-type class-or-interface-heritage-type patterns captures 1 name entity.name.type.module.ts 2 name punctuation.accessor.ts match ([_$[:alpha:]][_$[:alnum:]]*)\s*(\.) name meta.object.heritage.parent.ts captures 1 name entity.other.inherited-class.ts match ([_$[:alpha:]][_$[:alnum:]]*) name meta.object.heritage.parent.ts class-or-interface-name captures 0 name entity.name.class.ts match [_$[:alpha:]][_$[:alnum:]]* name meta.object.name.ts comment patterns begin /\*\*(?!/) captures 0 name punctuation.definition.comment.ts end \*/ name comment.block.documentation.ts patterns include #docblock begin /\* captures 0 name punctuation.definition.comment.ts end \*/ name comment.block.ts begin (^[ \t]+)?(?=//) beginCaptures 1 name punctuation.whitespace.comment.leading.ts end (?!\G) patterns begin // beginCaptures 0 name punctuation.definition.comment.ts end \n name comment.line.double-slash.ts control-statement patterns match (?<!\.|\$)\b(catch|finally|throw|try)\b(?!\$) name keyword.control.trycatch.ts match (?<!\.|\$)\b(break|continue|do|goto|while)\b(?!\$) name keyword.control.loop.ts match (?<!\.|\$)\b(await|return)\b(?!\$) name keyword.control.flow.ts captures 1 name keyword.control.flow.ts 2 name keyword.generator.asterisk.ts match (?<!\.|\$)\b(yield)\b(?!\$)(?:\s*(\*))? match (?<!\.|\$)\b(case|default|switch)\b(?!\$) name keyword.control.switch.ts match (?<!\.|\$)\b(else|if)\b(?!\$) name keyword.control.conditional.ts match (?<!\.|\$)\b(with)\b(?!\$) name keyword.control.with.ts match (?<!\.|\$)\b(debugger)\b(?!\$) name keyword.other.ts match (?<!\.|\$)\b(declare)\b(?!\$) name storage.modifier.ts decl-block begin \{ beginCaptures 0 name punctuation.definition.block.ts end \} endCaptures 0 name punctuation.definition.block.ts name meta.block.ts patterns include #statements declaration name meta.declaration.ts patterns include #decorator include #var-expr include #function-declaration include #class-or-interface-declaration include #type-declaration include #enum-declaration include #namespace-declaration include #import-equals-declaration include #import-declaration include #export-declaration decorator begin (?<!\.|\$)\@ beginCaptures 0 name punctuation.decorator.ts end (?=\s) name meta.decorator.ts patterns include #expression destructuring-parameter patterns begin (?<!=|:)\s*(\{) beginCaptures 1 name punctuation.definition.binding-pattern.object.ts end \} endCaptures 0 name punctuation.definition.binding-pattern.object.ts name meta.parameter.object-binding-pattern.ts patterns include #parameter-object-binding-element begin (?<!=|:)\s*(\[) beginCaptures 1 name punctuation.definition.binding-pattern.array.ts end \] endCaptures 0 name punctuation.definition.binding-pattern.array.ts name meta.paramter.array-binding-pattern.ts patterns include #parameter-array-binding-element destructuring-variable patterns begin (?<!=|:|of|in)\s*(\{) beginCaptures 1 name punctuation.definition.binding-pattern.object.ts end (?=$|[;,}]|(\s+(of|in)\s+)) name meta.object-binding-pattern-variable.ts patterns include #variable-initializer begin \G end (?!\G)(?=$|[;,=}]|(\s+(of|in)\s+)) patterns begin \G end \} endCaptures 0 name punctuation.definition.binding-pattern.object.ts patterns include #object-binding-element include #type-annotation include #comment begin (?<!=|:|of|in)\s*(\[) beginCaptures 1 name punctuation.definition.binding-pattern.array.ts end (?=$|[;,}]|(\s+(of|in)\s+)) name meta.array-binding-pattern-variable.ts patterns include #variable-initializer begin \G end (?!\G)(?=$|[;,=}]|(\s+(of|in)\s+)) patterns begin \G end \] endCaptures 0 name punctuation.definition.binding-pattern.array.ts patterns include #array-binding-element include #type-annotation include #comment docblock patterns match (?<!\w)@(abstract|access|alias|arg|argument|async|attribute|augments|author|beta|borrows|bubbes|callback|chainable|class|classdesc|code|config|const|constant|constructor|constructs|copyright|default|defaultvalue|define|deprecated|desc|description|dict|emits|enum|event|example|exports?|extends|extension|extension_for|extensionfor|external|file|fileoverview|final|fires|for|function|global|host|ignore|implements|inherit[Dd]oc|inner|instance|interface|kind|lends|license|listens|main|member|memberof|method|mixex|mixins?|module|name|namespace|nocollapse|nosideeffects|override|overview|package|param|preserve|private|prop|property|protected|public|read[Oo]nly|record|require[ds]|returns?|see|since|static|struct|submodule|summary|template|this|throws|todo|tutorial|type|typedef|unrestricted|uses|var|variation|version|virtual|writeOnce)\b name storage.type.class.jsdoc captures 0 name other.meta.jsdoc 1 name entity.name.type.instance.jsdoc 2 name variable.other.jsdoc 3 name other.description.jsdoc match ({\b(?:[_$[:alpha:]][_$[:alnum:]]*)\b})\s\b([_$[:alpha:]][_$[:alnum:]]*)\b\s*((?:(?!\*\/).)*) enum-declaration captures 1 name keyword.control.export.ts 2 name storage.modifier.ts 3 name storage.type.enum.ts 4 name entity.name.type.enum.ts match (?<!\.|\$)(?:(\bexport)\s+)?(?:\b(const)\s+)?\b(enum)\s+([_$[:alpha:]][_$[:alnum:]]*) name meta.enum.declaration.ts export-declaration patterns captures 1 name keyword.control.export.ts 2 name keyword.control.as.ts 3 name storage.type.namespace.ts 4 name entity.name.type.module.ts match (?<!\.|\$)\b(export)\s+(as)\s+(namespace)\s+([_$[:alpha:]][_$[:alnum:]]*) begin (?<!\.|\$)\b(export)(?:(?:\s*(=))|(?:\s+(default)\s+)) beginCaptures 1 name keyword.control.export.ts 2 name keyword.operator.assignment.ts 3 name keyword.control.default.ts end (?=;|\bexport\b|\bfunction\b|\bclass\b|\binterface\b|\blet\b|\bvar\b|\bconst\b|\bimport\b|\benum\b|\bnamespace\b|\bmodule\b|\btype\b|\babstract\b|\bdeclare\b|\basync\b|$) name meta.export.default.ts patterns include #expression begin (?<!\.|\$)\b(export)(?!(\s*:)|(\$))\b beginCaptures 0 name keyword.control.export.ts end (?=;|\bexport\b|\bfunction\b|\bclass\b|\binterface\b|\blet\b|\bvar\b|\bconst\b|\bimport\b|\benum\b|\bnamespace\b|\bmodule\b|\btype\b|\babstract\b|\bdeclare\b|\basync\b|$) name meta.export.ts patterns include #import-export-declaration expression name meta.expression.ts patterns include #string include #regex include #template include #comment include #literal include #function-declaration include #class-or-interface-declaration include #cast include #arrow-function include #paren-expression include #ternary-expression include #new-expr include #object-literal include #expression-operator include #operators include #function-call expression-operator patterns match (?<!\.|\$)\bdelete\b(?!\$) name keyword.operator.delete.ts match (?<!\.|\$)\bin\b(?!\$) name keyword.operator.in.ts match (?<!\.|\$)\bof\b(?!\$) name keyword.operator.of.ts match (?<!\.|\$)\binstanceof\b(?!\$) name keyword.operator.instanceof.ts match (?<!\.|\$)\bnew\b(?!\$) name keyword.operator.new.ts match (?<!\.|\$)\btypeof\b(?!\$) name keyword.operator.typeof.ts match (?<!\.|\$)\bvoid\b(?!\$) name keyword.operator.void.ts match (?<!\.|\$)\bas\b(?!\$) name keyword.control.as.ts match (?<!\.|\$)\bis\b(?!\$) name keyword.operator.is.ts field-declaration begin (?<!\()\s*((?:[_$[:alpha:]][_$[:alnum:]]*)|(?:\'[^']*\')|(?:\"[^"]*\"))\s*(\?\s*)?(?=(=|:)) beginCaptures 1 name variable.object.property.ts 2 name keyword.operator.optional.ts end (?=\}|;|,|$)|(?<=\}) name meta.field.declaration.ts patterns include #variable-initializer begin \G end (?!\G)(?=[};,=]|$)|(?<=\}) patterns include #type-annotation include #string include #comment for-loop begin (?<!\.|\$)\b(for)\s*(\() beginCaptures 1 name keyword.control.loop.ts 2 name meta.brace.round.ts end \) endCaptures 0 name meta.brace.round.ts patterns include #var-expr include #expression function-call name functioncall.expr.ts patterns begin ([_$[:alpha:]][_$[:alnum:]]*)\s*(<)(?=[^<>]*(\<[^<>]+\>)*[^<>]*(\<[^<>]+\>)*[^<>]*>\s*\() beginCaptures 1 name entity.name.function.ts 2 name punctuation.definition.typeparameters.begin.ts end (>) endCaptures 1 name punctuation.definition.typeparameters.end.ts name meta.type.parameters.ts patterns include #type include #paren-expression function-declaration begin (?<!\.|\$)\b(?:(export)\s+)?(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s* beginCaptures 1 name keyword.control.export.ts 2 name storage.modifier.async.ts 3 name storage.type.function.ts 4 name keyword.generator.asterisk.ts 5 name entity.name.function.ts end (?=;|\})|(?<=\}) name meta.function.ts patterns include #comment include #type-parameters include #function-parameters include #return-type include #function-overload-declaration include #decl-block function-overload-declaration captures 1 name keyword.control.export.ts 2 name storage.modifier.async.ts 3 name storage.type.function.ts 4 name keyword.generator.asterisk.ts 5 name entity.name.function.ts match (?<!\.|\$)\b(?:(export)\s+)?(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s* name meta.function.overload.ts function-parameters begin \( beginCaptures 0 name punctuation.definition.parameters.begin.ts end \) endCaptures 0 name punctuation.definition.parameters.end.ts name meta.parameters.ts patterns include #comment include #decorator include #destructuring-parameter include #parameter-name include #type-annotation include #variable-initializer import-declaration begin (?<!\.|\$)(?:(\bexport)\s+)?\b(import)(?!(\s*:)|(\$))\b beginCaptures 1 name keyword.control.export.ts 2 name keyword.control.import.ts end (?=;|$) name meta.import.ts patterns include #import-export-declaration import-equals-declaration patterns begin (?<!\.|\$)(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(require)\s*(\() beginCaptures 1 name keyword.control.export.ts 2 name keyword.control.import.ts 3 name variable.other.readwrite.alias.ts 4 name keyword.operator.assignment.ts 5 name keyword.control.require.ts 6 name meta.brace.round.ts end \) endCaptures 0 name meta.brace.round.ts name meta.import-equals.external.ts patterns include #comment include #string begin (?<!\.|\$)(?:(\bexport)\s+)?\b(import)\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(?!require\b) beginCaptures 1 name keyword.control.export.ts 2 name keyword.control.import.ts 3 name variable.other.readwrite.alias.ts 4 name keyword.operator.assignment.ts end (?=;|$) name meta.import-equals.internal.ts patterns include #comment captures 1 name entity.name.type.module.ts 2 name punctuation.accessor.ts match ([_$[:alpha:]][_$[:alnum:]]*)\s*(\.) match ([_$[:alpha:]][_$[:alnum:]]*) name variable.other.readwrite.ts import-export-block begin \{ beginCaptures 0 name punctuation.definition.block.ts end \} endCaptures 0 name punctuation.definition.block.ts name meta.block.ts patterns include #import-export-clause import-export-clause patterns include #comment captures 1 name keyword.control.default.ts 2 name constant.language.import-export-all.ts 3 name variable.other.readwrite.ts 4 name keyword.control.as.ts 5 name invalid.illegal.ts 6 name variable.other.readwrite.alias.ts comment (default|*|name) as alias match (?x) (?: \b(default)\b | (\*) | ([_$[:alpha:]][_$[:alnum:]]*)) \s+ (as) \s+ (?: (\b default \b | \*) | ([_$[:alpha:]][_$[:alnum:]]*)) match , name meta.delimiter.object.comma.ts match \* name constant.language.import-export-all.ts match \b(default)\b name keyword.control.default.ts match ([_$[:alpha:]][_$[:alnum:]]*) name variable.other.readwrite.alias.ts import-export-declaration patterns include #comment include #string include #import-export-block match \bfrom\b name keyword.control.from.ts include #import-export-clause indexer-declaration begin \[ beginCaptures 0 name meta.brace.square.ts end (\])\s*(\?\s*)?|$ endCaptures 1 name meta.brace.square.ts 2 name keyword.operator.optional.ts name meta.indexer.declaration.ts patterns include #type-annotation include #indexer-parameter indexer-parameter captures 1 name variable.parameter.ts match ([_$[:alpha:]][_$[:alnum:]]*)(?=\:) name meta.indexer.parameter.ts literal name literal.ts patterns include #numeric-literal include #boolean-literal include #null-literal include #undefined-literal include #numericConstant-literal include #array-literal include #this-literal include #super-literal method-declaration begin (?<!\.|\$)(?:\b(abstract)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?=((\bnew)|(?:\b(constructor)\b)|((?:(\*)\s*)?((?:[_$[:alpha:]][_$[:alnum:]]*)|(?:\'[^']*\')|(?:\"[^"]*\")|(?:\[[^\]]*\]))\s*(\??)))?\s*[\(\<]) beginCaptures 1 name storage.modifier.ts 2 name storage.modifier.ts 3 name storage.modifier.async.ts 4 name storage.type.property.ts end (?=\}|;|,)|(?<=\}) name meta.method.declaration.ts patterns include #method-declaration-name include #comment include #type-parameters include #function-parameters include #return-type include #method-overload-declaration include #decl-block method-declaration-name begin \G end (?=\(|\<) patterns captures 1 name keyword.generator.asterisk.ts match (\*)\s* include #string include #array-literal match \bnew(?=\s*[\(\<]) name keyword.operator.new.ts match \bconstructor\b(?=\s*[\(\<]) name storage.type.ts match [_$[:alpha:]][_$[:alnum:]]* name entity.name.function.ts match \? name keyword.operator.optional.ts method-overload-declaration begin (?<!\.|\$)(?:\b(abstract)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?=((\bnew)|(?:\b(constructor)\b)|((?:(\*)\s*)?((?:[_$[:alpha:]][_$[:alnum:]]*)|(?:\'[^']*\')|(?:\"[^"]*\")|(?:\[[^\]]*\]))\s*(\??)))?\s*[\(\<]) beginCaptures 1 name storage.modifier.ts 2 name storage.modifier.ts 3 name storage.modifier.ts 4 name storage.type.property.ts end (?=\(|\<) name meta.method.overload.declaration.ts patterns include #method-declaration-name namespace-declaration begin (?<!\.|\$)(?:(\bexport)\s+)?\b(namespace|module)\s+ beginCaptures 1 name keyword.control.export.ts 2 name storage.type.namespace.ts end (?=$|\{) name meta.namespace.declaration.ts patterns include #comment include #string match ([_$[:alpha:]][_$[:alnum:]]*) name entity.name.type.module.ts match \. name punctuation.accessor.ts new-expr begin (?<!\.|\$)\b(new)\b(?!\$) beginCaptures 1 name keyword.operator.new.ts end (?=[(;),]|$) name new.expr.ts patterns include #type null-literal match (?<!\.|\$)\bnull\b(?!\$) name constant.language.null.ts numeric-literal patterns match \b(?<!\$)0(x|X)[0-9a-fA-F]+\b(?!\$) name constant.numeric.hex.ts match \b(?<!\$)0(b|B)[01]+\b(?!\$) name constant.numeric.binary.ts match \b(?<!\$)0(o|O)?[0-7]+\b(?!\$) name constant.numeric.octal.ts captures 0 name constant.numeric.decimal.ts 1 name meta.delimiter.decimal.period.ts 2 name meta.delimiter.decimal.period.ts 3 name meta.delimiter.decimal.period.ts 4 name meta.delimiter.decimal.period.ts 5 name meta.delimiter.decimal.period.ts 6 name meta.delimiter.decimal.period.ts match (?x) (?<!\$)(?: (?:\b[0-9]+(\.)[0-9]+[eE][+-]?[0-9]+\b)| # 1.1E+3 (?:\b[0-9]+(\.)[eE][+-]?[0-9]+\b)| # 1.E+3 (?:\B(\.)[0-9]+[eE][+-]?[0-9]+\b)| # .1E+3 (?:\b[0-9]+[eE][+-]?[0-9]+\b)| # 1E+3 (?:\b[0-9]+(\.)[0-9]+\b)| # 1.1 (?:\b[0-9]+(\.)\B)| # 1. (?:\B(\.)[0-9]+\b)| # .1 (?:\b[0-9]+\b(?!\.)) # 1 )(?!\$) numericConstant-literal patterns match (?<!\.|\$)\bNaN\b(?!\$) name constant.language.nan.ts match (?<!\.|\$)\bInfinity\b(?!\$) name constant.language.infinity.ts object-binding-element patterns include #comment begin ([_$[:alpha:]][_$[:alnum:]]*)\s*(:) beginCaptures 1 name variable.object.property.ts 2 name punctuation.destructuring.ts end (?=,|\}) patterns include #object-binding-pattern include #array-binding-pattern match ([_$[:alpha:]][_$[:alnum:]]*) name variable.other.readwrite.ts match ([_$[:alpha:]][_$[:alnum:]]*) name variable.other.readwrite.ts match , name meta.delimiter.object.comma.ts object-binding-pattern begin \{ beginCaptures 0 name punctuation.definition.binding-pattern.object.ts end \} endCaptures 0 name punctuation.definition.binding-pattern.object.ts patterns include #object-binding-element object-literal begin \{ beginCaptures 0 name punctuation.definition.block.ts end \} endCaptures 0 name punctuation.definition.block.ts name meta.object-literal.ts patterns include #object-member object-member patterns include #comment include #method-declaration begin [_$[:alpha:]][_$[:alnum:]]*\s*: end (?=,|\}) name meta.object.member.ts patterns include #expression operators patterns match \*=|(?<!\()/=|%=|\+=|\-= name keyword.operator.assignment.compound.ts match \&=|\^=|<<=|>>=|>>>=|\|= name keyword.operator.assignment.compound.bitwise.ts match ===|!==|==|!= name keyword.operator.comparison.ts match <=|>=|<>|<|> name keyword.operator.relational.ts match \!|&&|\|\| name keyword.operator.logical.ts match \&|~|\^|\| name keyword.operator.bitwise.ts match \= name keyword.operator.assignment.ts match -- name keyword.operator.decrement.ts match \+\+ name keyword.operator.increment.ts match %|\*|/|-|\+ name keyword.operator.arithmetic.ts parameter-array-binding-element patterns include #comment include #parameter-object-binding-pattern include #parameter-array-binding-pattern match ([_$[:alpha:]][_$[:alnum:]]*) name variable.parameter.ts match , name meta.delimiter.object.comma.ts parameter-array-binding-pattern begin \[ beginCaptures 0 name punctuation.definition.binding-pattern.array.ts end \] endCaptures 0 name punctuation.definition.binding-pattern.array.ts patterns include #parameter-array-binding-element parameter-name captures 1 name storage.modifier.ts 2 name keyword.operator.spread.ts 3 name variable.parameter.ts 4 name keyword.operator.optional.ts match (?:\s*\b(public|private|protected)\b\s+)?(\.\.\.)?\s*(?<!=|:)([_$[:alpha:]][_$[:alnum:]]*)\s*(\??) parameter-object-binding-element patterns include #comment begin ([_$[:alpha:]][_$[:alnum:]]*)\s*(:) beginCaptures 1 name variable.object.property.ts 2 name punctuation.destructuring.ts end (?=,|\}) patterns include #parameter-object-binding-pattern include #parameter-array-binding-pattern match ([_$[:alpha:]][_$[:alnum:]]*) name variable.parameter.ts match ([_$[:alpha:]][_$[:alnum:]]*) name variable.parameter.ts match , name meta.delimiter.object.comma.ts parameter-object-binding-pattern begin \{ beginCaptures 0 name punctuation.definition.binding-pattern.object.ts end \} endCaptures 0 name punctuation.definition.binding-pattern.object.ts patterns include #parameter-object-binding-element paren-expression begin \( beginCaptures 0 name meta.brace.round.ts end \) endCaptures 0 name meta.brace.round.ts patterns include #expression property-accessor match (?<!\.|\$)\b(get|set)\b(?!\$) name storage.type.property.ts qstring-double begin " beginCaptures 0 name punctuation.definition.string.begin.ts end (")|((?:[^\\\n])$) endCaptures 1 name punctuation.definition.string.end.ts 2 name invalid.illegal.newline.ts name string.quoted.double.ts patterns include #string-character-escape qstring-single begin ' beginCaptures 0 name punctuation.definition.string.begin.ts end (\')|((?:[^\\\n])$) endCaptures 1 name punctuation.definition.string.end.ts 2 name invalid.illegal.newline.ts name string.quoted.single.ts patterns include #string-character-escape regex begin (?<=[=(:,\[?+!]|^|return|=>|&&|\|\|)\s*(/)(?![/*+{}?])(?=.*/) beginCaptures 1 name punctuation.definition.string.begin.ts end (/)([gimuy]*) endCaptures 1 name punctuation.definition.string.end.ts 2 name keyword.other.ts name string.regex.ts patterns include #regexp regex-character-class patterns match \\[wWsSdD]|\. name constant.other.character-class.regexp match \\([0-7]{3}|x\h\h|u\h\h\h\h) name constant.character.numeric.regexp match \\c[A-Z] name constant.character.control.regexp match \\. name constant.character.escape.backslash.regexp regexp patterns match \\[bB]|\^|\$ name keyword.control.anchor.regexp match \\[1-9]\d* name keyword.other.back-reference.regexp match [?+*]|\{(\d+,\d+|\d+,|,\d+|\d+)\}\?? name keyword.operator.quantifier.regexp match \| name keyword.operator.or.regexp begin (\()((\?=)|(\?!)) beginCaptures 1 name punctuation.definition.group.regexp 2 name punctuation.definition.group.assertion.regexp 3 name meta.assertion.look-ahead.regexp 4 name meta.assertion.negative-look-ahead.regexp end (\)) endCaptures 1 name punctuation.definition.group.regexp name meta.group.assertion.regexp patterns include #regexp begin \((\?:)? beginCaptures 0 name punctuation.definition.group.regexp 1 name punctuation.definition.group.capture.regexp end \) endCaptures 0 name punctuation.definition.group.regexp name meta.group.regexp patterns include #regexp begin (\[)(\^)? beginCaptures 1 name punctuation.definition.character-class.regexp 2 name keyword.operator.negation.regexp end (\]) endCaptures 1 name punctuation.definition.character-class.regexp name constant.other.character-class.set.regexp patterns captures 1 name constant.character.numeric.regexp 2 name constant.character.control.regexp 3 name constant.character.escape.backslash.regexp 4 name constant.character.numeric.regexp 5 name constant.character.control.regexp 6 name constant.character.escape.backslash.regexp match (?:.|(\\(?:[0-7]{3}|x\h\h|u\h\h\h\h))|(\\c[A-Z])|(\\.))\-(?:[^\]\\]|(\\(?:[0-7]{3}|x\h\h|u\h\h\h\h))|(\\c[A-Z])|(\\.)) name constant.other.character-class.range.regexp include #regex-character-class include #regex-character-class return-type begin (?<=\))\s*: end (?<!:)((?=$)|(?=\{|;|//)) name meta.return.type.ts patterns include #comment begin (?<=:)\s*(\{) beginCaptures 1 name punctuation.definition.block.ts end \} endCaptures 0 name punctuation.definition.block.ts name meta.object.type.ts patterns include #type-object-members include #type statements patterns include #string include #regex include #template include #comment include #literal include #declaration include #switch-statement include #for-loop include #after-operator-block include #decl-block include #control-statement include #expression static-modifier match (?<!\.|\$)\b(static)\b(?!\$) name storage.modifier.ts string name string.ts patterns include #qstring-single include #qstring-double string-character-escape match \\(x\h{2}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$) name constant.character.escape.ts super-literal match (?<!\.|\$)\bsuper\b(?!\$) name variable.language.super.ts switch-block begin { beginCaptures 0 name punctuation.definition.block.ts end (?=\}) name switch-block.expr.ts patterns include #case-clause include #statements switch-expression begin (?<!\.|\$)\b(switch)\s*(\() beginCaptures 1 name keyword.control.switch.ts 2 name meta.brace.round.ts end \) endCaptures 0 name meta.brace.round.ts name switch-expression.expr.ts patterns include #expression switch-statement begin (?<!\.|\$)(?=\bswitch\s*\() end } endCaptures 0 name punctuation.definition.block.ts name switch-statement.expr.ts patterns include #switch-expression include #switch-block template begin ([_$[:alpha:]][_$[:alnum:]]*)?(`) beginCaptures 1 name entity.name.function.tagged-template.ts 2 name punctuation.definition.string.template.begin.ts end ` endCaptures 0 name punctuation.definition.string.template.end.ts name string.template.ts patterns include #template-substitution-element include #string-character-escape template-substitution-element begin \$\{ beginCaptures 0 name punctuation.definition.template-expression.begin.ts end \} endCaptures 0 name punctuation.definition.template-expression.end.ts name meta.template.expression.ts patterns include #expression ternary-expression begin (?=\?) end (?=$|[;,})\]]) patterns include #ternary-operator include #expression ternary-operator begin (\?) beginCaptures 0 name keyword.operator.ternary.ts end (:) endCaptures 0 name keyword.operator.ternary.ts patterns include #expression this-literal match (?<!\.|\$)\bthis\b(?!\$) name variable.language.this.ts type name meta.type.ts patterns include #comment include #string include #type-primitive include #type-parameters include #type-tuple include #type-object include #type-operator include #type-paren-or-function-parameters include #type-function-return-type include #type-name type-annotation begin : end (?=$|[,);\}\]]|//)|(?==[^>])|(?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{) name meta.type.annotation.ts patterns include #comment include #expression-operator include #type type-declaration begin (?<!\.|\$)(?:(\bexport)\s+)?\b(type)\b\s+([_$[:alpha:]][_$[:alnum:]]*)\s* beginCaptures 1 name keyword.control.export.ts 2 name storage.type.type.ts 3 name entity.name.type.ts end (?=$|[,);>]|\bvar\b|\blet\b|\bconst\b|\btype\b|\bfunction\b|\bclass\b|\binterface\b|\bnamespace\b|\bmodule\b|\bimport\b|\benum\b|\bdeclare\b|\bexport\b|\babstract\b|\basync\b) name meta.type.declaration.ts patterns include #comment include #type-parameters include #type match =\s* name keyword.operator.assignment.ts type-function-return-type begin => beginCaptures 0 name storage.type.function.arrow.ts end (?<!=>)(?=[,\]\)\{\}=;>]|//|$) name meta.type.function.return.ts patterns include #comment begin (?<==>)\s*(\{) beginCaptures 1 name punctuation.definition.block.ts end \} endCaptures 0 name punctuation.definition.block.ts name meta.object.type.ts patterns include #type-object-members include #type type-name patterns captures 1 name entity.name.type.module.ts 2 name punctuation.accessor.ts match ([_$[:alpha:]][_$[:alnum:]]*)\s*(\.) match [_$[:alpha:]][_$[:alnum:]]* name entity.name.type.ts type-object begin \{ beginCaptures 0 name punctuation.definition.block.ts end \} endCaptures 0 name punctuation.definition.block.ts name meta.object.type.ts patterns include #type-object-members type-object-members patterns include #comment include #field-declaration include #method-declaration include #indexer-declaration include #type-annotation type-operator match [&|] name keyword.operator.type.ts type-parameters begin (<) beginCaptures 1 name punctuation.definition.typeparameters.begin.ts end (?=$)|(>) endCaptures 1 name punctuation.definition.typeparameters.end.ts name meta.type.parameters.ts patterns include #comment match (?<!\.|\$)\b(extends)\b(?!\$) name storage.modifier.ts include #type type-paren-or-function-parameters begin (?:(?<!\.|\$)\b(new)\b)?\s*(\() beginCaptures 1 name keyword.control.new.ts 2 name meta.brace.round.ts end \) endCaptures 0 name meta.brace.round.ts name meta.type.paren.cover.ts patterns include #type include #function-parameters type-primitive match (?<!\.|\$)\b(string|number|boolean|symbol|any|void|never)\b(?!\$) name support.type.primitive.ts type-tuple begin \[ beginCaptures 0 name meta.brace.square.ts end \] endCaptures 0 name meta.brace.square.ts name meta.type.tuple.ts patterns include #type undefined-literal match (?<!\.|\$)\bundefined\b(?!\$) name constant.language.undefined.ts var-expr begin (?<!\.|\$)(?:(\bexport)\s+)?\b(var|let|const(?!\s+enum\b))\b(?!\$) beginCaptures 1 name keyword.control.export.ts 2 name storage.type.ts end (?=$|;|}|(\s+(of|in)\s+)) name meta.var.expr.ts patterns include #destructuring-variable include #var-single-variable include #comment var-single-variable begin ([_$[:alpha:]][_$[:alnum:]]*) beginCaptures 1 name variable.other.readwrite.ts end (?=$|[;,}]|(\s+(of|in)\s+)) name meta.var-single-variable.expr.ts patterns include #variable-initializer begin \G end (?!\G)(?=$|[;,=}]|(\s+(of|in)\s+)) patterns include #type-annotation include #string include #comment variable-initializer begin (?<!=|!)(=)(?!=) beginCaptures 1 name keyword.operator.assignment.ts end (?=$|[,);}]) patterns include #expression scopeName source.ts uuid ef98eb90-bf9b-11e4-bb52-0800200c9a66