# [PackageDev] target_format: plist, ext: tmLanguage

---

name: TypeScript

scopeName: source.ts

fileTypes: [ts]

uuid: ef98eb90-bf9b-11e4-bb52-0800200c9a66

patterns:

- include: '#expression'

repository:

var-expr:

name: meta.var.expr.ts

begin: (?<!\()\s*\b(var|let|const(?!\s+enum))\s+([a-zA-Z_$][\w$]*)

beginCaptures:

'1': { name: storage.type.ts }

'2': { name: variable.ts }

end: '$|(?=[;=\}\{])|(?<=\})'

patterns:

- include: '#type-annotation'

control-statement:

name: keyword.control.ts

match: \b(break|catch|continue|declare|do|else|finally|for|if|return|switch|throw|try|while)\b

switch-case:

name: case.expr.ts

begin: '\b(case|default)\b'

beginCaptures:

'1': { name: keyword.control.ts }

end: ':'

patterns:

- include: '#expression'

declaration:

name: meta.declaration.ts

patterns:

- include: '#function-declaration'

- include: '#object-declaration'

- include: '#type-declaration'

- include: '#enum-declaration'

type-declaration:

name: meta.type.declaration.ts

begin: \b(type)\b\s+([a-zA-Z_$][\w$]*)\s*=\s*

beginCaptures:

'1': { name: keyword.other.ts }

'2': { name: storage.type.ts }

end: (?=[,);>]|var|type|function|class|interface)

patterns:

- include: '#type'

enum-declaration:

name: meta.enum.declaration.ts

match: (?:\b(const)\s+)?\b(enum)\s+([a-zA-Z_$][\w$]*)

captures:

'1': { name: storage.modifier.ts}

'2': { name: storage.type.ts }

'3': { name: entity.name.type.ts }

object-declaration:

name: meta.declaration.object.ts

begin: '\b(?:(export)\s+)?\b(class|interface)\b(?:\s+([a-zA-Z_$][\w$]*))'

beginCaptures:

'1': { name: storage.modifier.ts }

'2': { name: storage.type.ts }

'3': { name: entity.name.class.ts }

end: (?=\})

endCaptures:

'1': { name: brace.curly.ts }

patterns:

- include: '#type-parameters'

- include: '#object-heritage'

- include: '#object-body'

- include: '#comment'

object-heritage:

name: meta.object.heritage.ts

match: (?:\b(extends|implements)\b|,)(?:\s+([a-zA-Z_$][.\w$]*))

captures:

'1': { name: keyword.other.ts }

'2': { name: storage.type.ts }

object-body:

name: meta.object.body.ts

begin: \{

end: (?=\})

patterns:

- include: '#comment'

- include: '#field-declaration'

- include: '#method-declaration'

- include: '#indexer-declaration'

- include: '#type-annotation'

- include: '#variable-initializer'

- include: '#access-modifier'

- include: '#static-modifier'

- include: '#property-accessor'

object-type:

name: meta.object.type.ts

begin: \{

end: \}

patterns:

- include: '#comment'

- include: '#field-declaration'

- include: '#method-declaration'

- include: '#indexer-declaration'

- include: '#type-annotation'

field-declaration:

name: meta.field.declaration.ts

match: '\b([a-zA-Z_$][\w$]*)\s*(\?\s*)?(?=(=|:))'

captures:

'1': { name: variable.ts }

'2': { name: keyword.operator.ts }

method-declaration:

name: meta.method.declaration.ts

begin: '\b(?:(get|set)\s+)?\[?([a-zA-Z_$][\.\w$]*)\s*\]?\s*(\??)\s*(?=\()'

beginCaptures:

'1': { name: storage.type.property.ts }

'2': { name: entity.name.function.ts }

'3': { name: keyword.operator.ts }

end: '\}|[;,]'

patterns:

- include: '#comment'

- include: '#function-parameters'

- include: '#type-annotation'

- include: '#decl-block'

indexer-declaration:

name: meta.indexer.declaration.ts

begin: \[

end: \]\s*(\?\s*)?|$

endCaptures:

'1': { name: keyword.operator.ts }

patterns:

- include: '#type-annotation'

- include: '#indexer-parameter'

- include: '#expression'

indexer-parameter:

name: meta.indexer.parameter.ts

match: ([a-zA-Z_$][\w$]*)(?=\:)

captures:

'1': { name: variable.parameter.ts}

function-declaration:

name: meta.function.ts

begin: \b(function)\b(?:\s+([a-zA-Z_$][\w$]*))?\s*

beginCaptures:

'1': { name: storage.type.function.ts }

'2': { name: entity.name.function.ts }

end: (?=;|\})

patterns:

- include: '#comment'

- include: '#type-parameters'

- include: '#function-parameters'

- include: '#return-type'

- include: '#decl-block'

block:

name: meta.block.ts

begin: \{

end: \}

patterns:

- include: '#expression'

- include: '#object-member'

decl-block:

name: meta.decl.block.ts

begin: \{

end: (?=\})

patterns:

- include: '#expression'

function-parameters:

name: meta.function-parameters.ts

begin: \(

end: \)

patterns:

- include: '#comment'

- include: '#parameter-name'

- include: '#type-annotation'

- include: '#variable-initializer'

function-type-parameters:

name: meta.function.type.ts

begin: (\()

beginCaptures:

'1': { name: brace.round.ts }

end: \)

endCaptures:

'1': { name: brace.round.ts }

patterns:

- include: '#comment'

- include: '#parameter-name'

- include: '#type-annotation'

- include: '#variable-initializer'

parameter-name:

name: parameter.name.ts

match: '(?:\s*\b(public|private)\b\s+)?(\.\.\.)?\s*([a-zA-Z_$][\w$]*)\s*(\??)'

captures:

'1': { name: storage.modifier.ts }

'2': { name: keyword.operator.ts }

'3': { name: variable.parameter.ts }

'4': { name: keyword.operator.ts }

return-type:

name: meta.return.type.ts

begin: '(?<=\)):'

end: $|(?=\{|;)

patterns:

- include: '#type'

type-annotation:

name: meta.type.annotation.ts

begin: ":"

end: (?=[,);}\[\]])|(?==[^>])|(?<=[a-z]|>)\s*(?=\{|$)

patterns:

- include: '#type'

type:

name: meta.type.ts

patterns:

- include: '#type-name'

- include: '#type-parameters'

- include: '#type-union'

- include: '#object-type'

- include: '#function-type-parameters'

- include: '#function-type-return-type'

function-type-return-type:

name: meta.function.type.return.ts

begin: '=>'

end: (?=[,\){=;])

patterns:

- include: '#type'

type-union:

name: meta.type.union.ts

begin: '(\|)'

beginCaptures:

'1': { name: keyword.operator.ts }

end: '([a-zA-Z_$][.\w$]*)'

endCaptures:

'1': { name: storage.type.ts }

patterns:

- include: '#comment'

type-name:

name: storage.type.ts

match: '[a-zA-Z_$][.\w$]*'

type-parameters:

name: meta.type.parameters.ts

begin: '<'

end: '(?=var|type|function|class|interface)|>'

patterns:

- name: keyword.other.ts

match: '\b(extends)\b'

- include: '#comment'

- include: '#type'

variable-initializer:

begin: (=)

beginCaptures:

'1': { name: keyword.operator.ts }

end: (?=[,);=])

patterns:

- include: '#expression'

expression:

name: meta.expression.ts

patterns:

- include: '#string'

- include: '#regex'

- include: '#template'

- include: '#comment'

- include: '#literal'

- include: '#paren-expression'

- include: '#var-expr'

- include: '#declaration'

- include: '#cast'

- include: '#new-expr'

- include: '#block'

- include: '#expression-operator'

- include: '#relational-operator'

- include: '#arithmetic-operator'

- include: '#logic-operator'

- include: '#assignment-operator'

- include: '#storage-keyword'

- include: '#control-statement'

- include: '#switch-case'

cast:

name: cast.expr.ts

match: '<\s*([a-zA-Z_$][.\w$]*)(\[\])*\s*>'

captures:

'1': { name: storage.type.ts }

new-expr:

name: new.expr.ts

match: '\b(new)\b\s*([a-zA-Z_$][.\w$]*)'

captures:

'1': { name: keyword.operator.ts }

'2': { name: storage.type.ts }

# TODO: object members with quoted or numric lhs

object-member:

name: meta.object.member.ts

begin: '[a-zA-Z_$][\w$]*\s*:'

end: (?=,|\})

patterns:

- include: '#expression'

expression-operator:

name: keyword.operator.ts

match: =>|\b(delete|export|import|in|instanceof|module|new|typeof|void)\b

arithmetic-operator:

name: keyword.operator.ts

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

relational-operator:

name: keyword.operator.ts

match: ===|==|=|!=|!==|<=|>=|<>|<|>

assignment-operator:

name: keyword.operator.ts

match: <<=|>>=|>>>=|\*=|(?<!\()/=|%=|\+=|\-=|&=|\^=

logic-operator:

name: keyword.operator.ts

match: \!|&|~|\||&&|\|\|

storage-keyword:

name: storage.type.ts

match: \b(number|boolean|string)\b

paren-expression:

begin: \(

beginCaptures:

'0': {name: brace.paren.ts }

end: \)

endCaptures:

'0': {name: brace.paren.ts }

patterns:

- include: '#expression'

qstring-double:

name: string.double.ts

begin: '"'

end: '"|(?=$)'

patterns:

- include: '#string-character-escape'

qstring-single:

name: string.single.ts

begin: "'"

end: "'|(?=$)"

patterns:

- include: '#string-character-escape'

regex:

name: string.regex.ts

begin: (?<=[=(:,\[]|^|return|&&|\|\||!)\s*(/)(?![/*+{}?])

end: $|(/)[igm]*

patterns:

- name: constant.character.escape.ts

match: \\.

- name: constant.character.class.ts

match: \[(\\\]|[^\]])*\]

string:

name: string.ts

patterns:

- include: '#qstring-single'

- include: '#qstring-double'

template:

name: meta.template.ts

begin: '`'

beginCaptures:

'0': { name: string.template.ts}

end: '`'

endCaptures:

'0': { name: string.template.ts}

patterns:

- include: '#template-substitution-element'

- include: '#template-string-contents'

template-string-contents:

name: string.template.ts

begin: '.*?'

end: (?=(\$\{|`))

patterns:

- include: '#string-character-escape'

string-character-escape:

name: constant.character.escape

match: \\(x\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)

template-substitution-element:

name: template.element.ts

begin: \$\{

beginCaptures:

'0': {name: keyword.operator.ts}

end: \}

endCaptures:

'0': {name: keyword.operator.ts}

patterns:

- include: '#expression'

comment:

name: comment.ts

patterns:

- include: '#comment-block-doc'

- include: '#comment-block'

- include: '#comment-line'

comment-block-doc:

name: comment.block.documentation.ts

begin: /\*\*(?!/)

end: \*/

comment-block:

name: comment.block.ts

begin: /\*

end: \*/

comment-line:

name: comment.line.ts

match: (//).*$\n?

literal:

name: literal.ts

patterns:

- include: '#numeric-literal'

- include: '#boolean-literal'

- include: '#null-literal'

- include: '#undefined-literal'

- include: '#array-literal'

array-literal:

name: meta.array.literal.ts

begin: \[

beginCaptures:

'0': { name: brace.square.ts }

end: \]

endCaptures:

'0': { name: brace.square.ts }

patterns:

- include: '#expression'

numeric-literal:

name: constant.numeric.ts

match: \b((0(x|X)[0-9a-fA-F]+)|([0-9]+(\.[0-9]+)?))\b

boolean-literal:

name: constant.language.boolean.ts

match: \b(false|true)\b

null-literal:

name: constant.language.null.ts

match: \b(null)\b

undefined-literal:

name: constant.language.ts

match: \b(undefined)\b

access-modifier:

name: storage.modifier.ts

match: \b(public|protected|private)\b

static-modifier:

name: keyword.other.ts

match: \b(static)\b

property-accessor:

name: storage.type.property.ts

match: \b(get|set)\b

...