@wooorm/starry-night
Version:
Syntax highlighting, like GitHub
1,371 lines (1,370 loc) • 102 kB
JavaScript
// This is a TextMate grammar distributed by `starry-night`.
// This grammar is developed at
// <https://github.com/jaseci-labs/jac-vscode>
// and licensed `mit`.
// See <https://github.com/wooorm/starry-night> for more info.
/**
* @import {Grammar} from '@wooorm/starry-night'
*/
/** @type {Grammar} */
const grammar = {
extensions: ['.jac'],
names: ['jac'],
patterns: [{include: '#elements'}],
repository: {
ability: {
patterns: [
{
begin:
'(?x)\\b(can|with|def|impl|sem)\\b(?=\\s*[[:alpha:]_]\\w*|\\s*({|;|\\(||\\n))',
beginCaptures: {1: {name: 'storage.type.function.jac'}},
end: '(?=\\)|{)|;',
endCaptures: {1: {name: 'punctuation.section.function.begin.jac'}},
name: 'meta.function.jac',
patterns: [
{include: '#comments'},
{match: ',', name: 'punctuation.separator.jac'},
{include: '#parameters'},
{include: '#builtin-types'},
{include: '#statement-keyword'},
{include: '#string'},
{include: '#archetype_refdef'},
{include: '#arch-reference'},
{include: '#arch-var-reference'},
{
match: '(?x)\n \\b ([[:alpha:]_]\\w*) \\b\n',
name: 'entity.name.function.jac'
}
]
}
]
},
'annotated-parameter': {
begin: '(?x)\n \\b\n ([[:alpha:]_]\\w*) \\s* (:)\n',
beginCaptures: {
1: {name: 'variable.parameter.function.language.jac'},
2: {name: 'punctuation.separator.annotation.jac'}
},
end: '(,)|(?=\\))',
endCaptures: {1: {name: 'punctuation.separator.parameters.jac'}},
patterns: [
{include: '#expression'},
{match: '=(?!=)', name: 'keyword.operator.assignment.jac'}
]
},
'arch-declaration': {
patterns: [
{
begin:
'(?x)\\s*(enum|obj|class|node|edge|walker|test)\\s*(?=\\s*[[:alpha:]_]\\w*|\\s*({|;|\\n))',
beginCaptures: {1: {name: 'storage.type.class.jac'}},
end: '({|;)',
endCaptures: {1: {name: 'punctuation.section.class.begin.jac'}},
name: 'meta.class.jac',
patterns: [{include: '#class-name'}, {include: '#class-inheritance'}]
}
]
},
'arch-reference': {
patterns: [
{
begin: '(impl|sem)\\s*(?=\\s*[[:alpha:]_]\\w*|\\s*( |:|\\n))',
beginCaptures: {1: {name: 'storage.type.class.jac'}},
end: '((?=:| )|;)',
endCaptures: {1: {name: 'punctuation.section.class.begin.jac'}},
name: 'meta.class.jac',
patterns: [{include: '#class-name'}, {include: '#class-inheritance'}]
}
]
},
'arch-var-reference': {
patterns: [
{
captures: {1: {name: 'storage.type.class.jac'}},
match: '(here|visitor|self|init|postinit|super|root)\\s*'
}
]
},
archetype: {
patterns: [
{
begin:
'(?x)\\b(enum|obj|class|node|edge|walker|test)\\b(?=\\s+[[:alpha:]_]\\w*|\\s*({|;|\\n))',
beginCaptures: {1: {name: 'storage.type.class.jac'}},
end: '(?={)|;',
endCaptures: {1: {name: 'punctuation.section.class.begin.jac'}},
name: 'meta.class.jac',
patterns: [{include: '#class-name'}, {include: '#class-inheritance'}]
}
]
},
archetype_refdef: {
patterns: [
{
begin: '(impl|sem)',
beginCaptures: {1: {name: 'storage.type.class.jac'}},
end: '(?=:|{|\\W)',
endCaptures: {1: {name: 'punctuation.section.class.begin.jac'}},
name: 'meta.class.jac',
patterns: [
{include: '#comments'},
{
match: '\\b([[:alpha:]_]\\w*)\\b',
name: 'entity.name.type.class.jac'
}
]
}
]
},
'assignment-operator': {
match:
'(?x)\n <<= | >>= | //= | \\*\\*=\n | \\+= | -= | /= | @=\n | \\*= | %= | ~= | \\^= | &= | \\|=\n | =(?!=)\n',
name: 'keyword.operator.assignment.jac'
},
'builtin-callables': {
patterns: [
{include: '#illegal-names'},
{include: '#illegal-object-name'},
{include: '#builtin-exceptions'},
{include: '#builtin-functions'},
{include: '#builtin-types'}
]
},
'builtin-exceptions': {
match:
'(?x) (?<!\\.) \\b(\n (\n Arithmetic | Assertion | Attribute | Buffer | BlockingIO\n | BrokenPipe | ChildProcess\n | (Connection (Aborted | Refused | Reset)?)\n | EOF | Environment | FileExists | FileNotFound\n | FloatingPoint | IO | Import | Indentation | Index | Interrupted\n | IsADirectory | NotADirectory | Permission | ProcessLookup\n | Timeout\n | Key | Lookup | Memory | Name | NotImplemented | OS | Overflow\n | Reference | Runtime | Recursion | Syntax | System\n | Tab | Type | UnboundLocal | Unicode(Encode|Decode|Translate)?\n | Value | Windows | ZeroDivision | ModuleNotFound\n ) Error\n|\n ((Pending)?Deprecation | Runtime | Syntax | User | Future | Import\n | Unicode | Bytes | Resource\n )? Warning\n|\n SystemExit | Stop(Async)?Iteration\n | KeyboardInterrupt\n | GeneratorExit | (Base)?Exception\n)\\b\n',
name: 'support.type.exception.jac'
},
'builtin-functions': {
patterns: [
{
match:
'(?x)\n (?<!\\.) \\b(\n __import__ | abs | aiter | all | anext | ascii | bin\n | breakpoint | callable | chr | compile | copyright | credits\n | delattr | dir | divmod | enumerate | eval | exec | exit\n | filter | format | getattr | globals | hasattr | hash | help\n | hex | id | input | isinstance | issubclass | iter | len\n | license | locals | map | max | memoryview | min | next\n | oct | open | ord | pow | print | quit | range | reload | repr\n | reversed | round | setattr | sorted | sum | vars | zip\n )\\b\n',
name: 'support.function.builtin.jac'
},
{
match:
'(?x)\n (?<!\\.) \\b(\n file | reduce | intern | raw_input | unicode | cmp | basestring\n | execfile | long | xrange\n )\\b\n',
name: 'variable.legacy.builtin.jac'
}
]
},
'builtin-possible-callables': {
patterns: [{include: '#builtin-callables'}, {include: '#magic-names'}]
},
'builtin-types': {
match:
'(?x)(?<!\\.) \\b(str|int|float|list|tuple|set|dict|bool|bytes|any|type)\\b\n',
name: 'support.type.jac'
},
c_style_block_comment: {
begin: '(#\\*)',
beginCaptures: {1: {name: 'punctuation.definition.comment.begin.jac'}},
end: '(\\*#)',
endCaptures: {1: {name: 'punctuation.definition.comment.end.jac'}},
name: 'comment.block.jac',
patterns: [{include: '#codetags'}]
},
'call-wrapper-inheritance': {
begin: '(?x)\n \\b(?=\n ([[:alpha:]_]\\w*) \\s* (\\()\n )\n',
end: '(\\))',
endCaptures: {1: {name: 'punctuation.definition.arguments.end.jac'}},
name: 'meta.function-call.jac',
patterns: [
{include: '#inheritance-name'},
{include: '#function-arguments'}
]
},
'class-inheritance': {
begin: '(\\()',
beginCaptures: {
1: {name: 'punctuation.definition.inheritance.begin.jac'}
},
end: '(\\))',
endCaptures: {1: {name: 'punctuation.definition.inheritance.end.jac'}},
name: 'meta.class.inheritance.jac',
patterns: [
{
match: '(\\*\\*|\\*)',
name: 'keyword.operator.unpacking.arguments.jac'
},
{match: ',', name: 'punctuation.separator.inheritance.jac'},
{match: '=(?!=)', name: 'keyword.operator.assignment.jac'},
{match: '\\bmetaclass\\b', name: 'support.type.metaclass.jac'},
{include: '#illegal-names'},
{include: '#class-kwarg'},
{include: '#call-wrapper-inheritance'},
{include: '#expression-base'},
{include: '#member-access-class'},
{include: '#inheritance-identifier'}
]
},
'class-kwarg': {
captures: {
1: {
name: 'entity.other.inherited-class.jac variable.parameter.class.jac'
},
2: {name: 'keyword.operator.assignment.jac'}
},
match: '(?x)\n \\b ([[:alpha:]_]\\w*) \\s*(=)(?!=)\n'
},
'class-name': {
patterns: [
{include: '#illegal-object-name'},
{include: '#builtin-possible-callables'},
{
match: '(?x)\n \\b ([[:alpha:]_]\\w*) \\b\n',
name: 'entity.name.type.class.jac'
}
]
},
codetags: {
captures: {1: {name: 'keyword.codetag.notation.jac'}},
match: '(?:\\b(NOTE|XXX|HACK|FIXME|BUG|TODO)\\b)'
},
comments: {
patterns: [
{include: '#c_style_block_comment'},
{include: '#py_style_comment'}
]
},
'comments-base': {
begin: '(\\#)',
beginCaptures: {1: {name: 'punctuation.definition.comment.jac'}},
end: '($)',
name: 'comment.line.number-sign.jac',
patterns: [{include: '#codetags'}]
},
'comments-string-double-three': {
begin: '(\\#)',
beginCaptures: {1: {name: 'punctuation.definition.comment.jac'}},
end: '($|(?="""))',
name: 'comment.line.number-sign.jac',
patterns: [{include: '#codetags'}]
},
'comments-string-single-three': {
begin: '(\\#)',
beginCaptures: {1: {name: 'punctuation.definition.comment.jac'}},
end: "($|(?='''))",
name: 'comment.line.number-sign.jac',
patterns: [{include: '#codetags'}]
},
'curly-braces': {
begin: '\\{',
beginCaptures: {0: {name: 'punctuation.definition.dict.begin.jac'}},
end: '\\}',
endCaptures: {0: {name: 'punctuation.definition.dict.end.jac'}},
patterns: [
{match: ':', name: 'punctuation.separator.dict.jac'},
{include: '#expression'}
]
},
decorator: {
begin: '(?x)\n ^\\s*\n ((@)) \\s* (?=[[:alpha:]_]\\w*)\n',
beginCaptures: {
1: {name: 'entity.name.function.decorator.jac'},
2: {name: 'punctuation.definition.decorator.jac'}
},
end: '(?x)\n ( \\) )\n # trailing whitespace and comments are legal\n (?: (.*?) (?=\\s*(?:\\#|$)) )\n | (?=\\n|\\#)\n',
endCaptures: {
1: {name: 'punctuation.definition.arguments.end.jac'},
2: {name: 'invalid.illegal.decorator.jac'}
},
name: 'meta.function.decorator.jac',
patterns: [{include: '#decorator-name'}, {include: '#function-arguments'}]
},
'decorator-name': {
patterns: [
{include: '#builtin-callables'},
{include: '#illegal-object-name'},
{
captures: {2: {name: 'punctuation.separator.period.jac'}},
match: '(?x)\n ([[:alpha:]_]\\w*) | (\\.)\n',
name: 'entity.name.function.decorator.jac'
},
{include: '#line-continuation'},
{
captures: {1: {name: 'invalid.illegal.decorator.jac'}},
match: '(?x)\n \\s* ([^([:alpha:]\\s_\\.#\\\\] .*?) (?=\\#|$)\n',
name: 'invalid.illegal.decorator.jac'
}
]
},
docstring: {
patterns: [
{
begin: '(\\\'\\\'\\\'|\\"\\"\\")',
beginCaptures: {1: {name: 'punctuation.definition.string.begin.jac'}},
end: '(\\1)',
endCaptures: {1: {name: 'punctuation.definition.string.end.jac'}},
name: 'string.quoted.docstring.multi.jac',
patterns: [
{include: '#docstring-prompt'},
{include: '#codetags'},
{include: '#docstring-guts-unicode'}
]
},
{
begin: '([rR])(\\\'\\\'\\\'|\\"\\"\\")',
beginCaptures: {
1: {name: 'storage.type.string.jac'},
2: {name: 'punctuation.definition.string.begin.jac'}
},
end: '(\\2)',
endCaptures: {1: {name: 'punctuation.definition.string.end.jac'}},
name: 'string.quoted.docstring.raw.multi.jac',
patterns: [
{include: '#string-consume-escape'},
{include: '#docstring-prompt'},
{include: '#codetags'}
]
},
{
begin: '(\\\'|\\")',
beginCaptures: {1: {name: 'punctuation.definition.string.begin.jac'}},
end: '(\\1)|(\\n)',
endCaptures: {
1: {name: 'punctuation.definition.string.end.jac'},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'string.quoted.docstring.single.jac',
patterns: [
{include: '#codetags'},
{include: '#docstring-guts-unicode'}
]
},
{
begin: '([rR])(\\\'|\\")',
beginCaptures: {
1: {name: 'storage.type.string.jac'},
2: {name: 'punctuation.definition.string.begin.jac'}
},
end: '(\\2)|(\\n)',
endCaptures: {
1: {name: 'punctuation.definition.string.end.jac'},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'string.quoted.docstring.raw.single.jac',
patterns: [
{include: '#string-consume-escape'},
{include: '#codetags'}
]
}
]
},
'docstring-guts-unicode': {
patterns: [
{include: '#escape-sequence-unicode'},
{include: '#escape-sequence'},
{include: '#string-line-continuation'}
]
},
'docstring-prompt': {
captures: {1: {name: 'keyword.control.flow.jac'}},
match:
"(?x)(?:(?:^|\\G) \\s* (?# '\\G' is necessary for ST)((?:>>>|\\.\\.\\.) \\s) (?=\\s*\\S))"
},
'docstring-statement': {
begin: '^(?=\\s*[rR]?(\\\'\\\'\\\'|\\"\\"\\"))',
end: '((?<=\\1)|^)(?!\\s*[rR]?(\\\'\\\'\\\'|\\"\\"\\"))',
patterns: [{include: '#docstring'}]
},
'double-one-regexp-character-set': {
patterns: [
{match: '(?x)\n \\[ \\^? \\] (?! .*?\\])\n'},
{
begin: '(\\[)(\\^)?(\\])?',
beginCaptures: {
1: {
name: 'punctuation.character.set.begin.regexp constant.other.set.regexp'
},
2: {name: 'keyword.operator.negation.regexp'},
3: {name: 'constant.character.set.regexp'}
},
end: '(\\]|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'punctuation.character.set.end.regexp constant.other.set.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'meta.character.set.regexp',
patterns: [
{include: '#regexp-charecter-set-escapes'},
{match: '[^\\n]', name: 'constant.character.set.regexp'}
]
}
]
},
'double-one-regexp-comments': {
begin: '\\(\\?#',
beginCaptures: {0: {name: 'punctuation.comment.begin.regexp'}},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {name: 'punctuation.comment.end.regexp'},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'comment.regexp',
patterns: [{include: '#codetags'}]
},
'double-one-regexp-conditional': {
begin: '(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)',
beginCaptures: {
0: {name: 'keyword.operator.conditional.regexp'},
1: {name: 'punctuation.parenthesis.conditional.begin.regexp'}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'keyword.operator.conditional.negative.regexp punctuation.parenthesis.conditional.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-expression': {
patterns: [
{include: '#regexp-base-expression'},
{include: '#double-one-regexp-character-set'},
{include: '#double-one-regexp-comments'},
{include: '#regexp-flags'},
{include: '#double-one-regexp-named-group'},
{include: '#regexp-backreference'},
{include: '#double-one-regexp-lookahead'},
{include: '#double-one-regexp-lookahead-negative'},
{include: '#double-one-regexp-lookbehind'},
{include: '#double-one-regexp-lookbehind-negative'},
{include: '#double-one-regexp-conditional'},
{include: '#double-one-regexp-parentheses-non-capturing'},
{include: '#double-one-regexp-parentheses'}
]
},
'double-one-regexp-lookahead': {
begin: '(\\()\\?=',
beginCaptures: {
0: {name: 'keyword.operator.lookahead.regexp'},
1: {name: 'punctuation.parenthesis.lookahead.begin.regexp'}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'keyword.operator.lookahead.regexp punctuation.parenthesis.lookahead.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-lookahead-negative': {
begin: '(\\()\\?!',
beginCaptures: {
0: {name: 'keyword.operator.lookahead.negative.regexp'},
1: {name: 'punctuation.parenthesis.lookahead.begin.regexp'}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'keyword.operator.lookahead.negative.regexp punctuation.parenthesis.lookahead.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-lookbehind': {
begin: '(\\()\\?<=',
beginCaptures: {
0: {name: 'keyword.operator.lookbehind.regexp'},
1: {name: 'punctuation.parenthesis.lookbehind.begin.regexp'}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'keyword.operator.lookbehind.regexp punctuation.parenthesis.lookbehind.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-lookbehind-negative': {
begin: '(\\()\\?<!',
beginCaptures: {
0: {name: 'keyword.operator.lookbehind.negative.regexp'},
1: {name: 'punctuation.parenthesis.lookbehind.begin.regexp'}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.lookbehind.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-named-group': {
begin: '(?x)\n (\\() (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n',
beginCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp'
},
2: {name: 'entity.name.tag.named.group.regexp'}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.named.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'meta.named.regexp',
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-parentheses': {
begin: '\\(',
beginCaptures: {
0: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.begin.regexp'
}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-one-regexp-parentheses-non-capturing': {
begin: '\\(\\?:',
beginCaptures: {
0: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.begin.regexp'
}
},
end: '(\\)|(?="))|((?=(?<!\\\\)\\n))',
endCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [{include: '#double-one-regexp-expression'}]
},
'double-three-regexp-character-set': {
patterns: [
{match: '(?x)\n \\[ \\^? \\] (?! .*?\\])\n'},
{
begin: '(\\[)(\\^)?(\\])?',
beginCaptures: {
1: {
name: 'punctuation.character.set.begin.regexp constant.other.set.regexp'
},
2: {name: 'keyword.operator.negation.regexp'},
3: {name: 'constant.character.set.regexp'}
},
end: '(\\]|(?="""))',
endCaptures: {
1: {
name: 'punctuation.character.set.end.regexp constant.other.set.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'meta.character.set.regexp',
patterns: [
{include: '#regexp-charecter-set-escapes'},
{match: '[^\\n]', name: 'constant.character.set.regexp'}
]
}
]
},
'double-three-regexp-comments': {
begin: '\\(\\?#',
beginCaptures: {0: {name: 'punctuation.comment.begin.regexp'}},
end: '(\\)|(?="""))',
endCaptures: {
1: {name: 'punctuation.comment.end.regexp'},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'comment.regexp',
patterns: [{include: '#codetags'}]
},
'double-three-regexp-conditional': {
begin: '(\\()\\?\\((\\w+(?:\\s+[[:alnum:]]+)?|\\d+)\\)',
beginCaptures: {
0: {name: 'keyword.operator.conditional.regexp'},
1: {name: 'punctuation.parenthesis.conditional.begin.regexp'}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'keyword.operator.conditional.negative.regexp punctuation.parenthesis.conditional.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-expression': {
patterns: [
{include: '#regexp-base-expression'},
{include: '#double-three-regexp-character-set'},
{include: '#double-three-regexp-comments'},
{include: '#regexp-flags'},
{include: '#double-three-regexp-named-group'},
{include: '#regexp-backreference'},
{include: '#double-three-regexp-lookahead'},
{include: '#double-three-regexp-lookahead-negative'},
{include: '#double-three-regexp-lookbehind'},
{include: '#double-three-regexp-lookbehind-negative'},
{include: '#double-three-regexp-conditional'},
{include: '#double-three-regexp-parentheses-non-capturing'},
{include: '#double-three-regexp-parentheses'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-lookahead': {
begin: '(\\()\\?=',
beginCaptures: {
0: {name: 'keyword.operator.lookahead.regexp'},
1: {name: 'punctuation.parenthesis.lookahead.begin.regexp'}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'keyword.operator.lookahead.regexp punctuation.parenthesis.lookahead.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-lookahead-negative': {
begin: '(\\()\\?!',
beginCaptures: {
0: {name: 'keyword.operator.lookahead.negative.regexp'},
1: {name: 'punctuation.parenthesis.lookahead.begin.regexp'}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'keyword.operator.lookahead.negative.regexp punctuation.parenthesis.lookahead.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-lookbehind': {
begin: '(\\()\\?<=',
beginCaptures: {
0: {name: 'keyword.operator.lookbehind.regexp'},
1: {name: 'punctuation.parenthesis.lookbehind.begin.regexp'}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'keyword.operator.lookbehind.regexp punctuation.parenthesis.lookbehind.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-lookbehind-negative': {
begin: '(\\()\\?<!',
beginCaptures: {
0: {name: 'keyword.operator.lookbehind.negative.regexp'},
1: {name: 'punctuation.parenthesis.lookbehind.begin.regexp'}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'keyword.operator.lookbehind.negative.regexp punctuation.parenthesis.lookbehind.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-named-group': {
begin: '(?x)\n (\\() (\\?P <\\w+(?:\\s+[[:alnum:]]+)?>)\n',
beginCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.named.begin.regexp'
},
2: {name: 'entity.name.tag.named.group.regexp'}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.named.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'meta.named.regexp',
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-parentheses': {
begin: '\\(',
beginCaptures: {
0: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.begin.regexp'
}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
'double-three-regexp-parentheses-non-capturing': {
begin: '\\(\\?:',
beginCaptures: {
0: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.begin.regexp'
}
},
end: '(\\)|(?="""))',
endCaptures: {
1: {
name: 'support.other.parenthesis.regexp punctuation.parenthesis.non-capturing.end.regexp'
},
2: {name: 'invalid.illegal.newline.jac'}
},
patterns: [
{include: '#double-three-regexp-expression'},
{include: '#comments-string-double-three'}
]
},
elements: {
patterns: [
{include: '#import'},
{include: '#global'},
{include: '#sem'},
{include: '#archetype'},
{include: '#archetype_refdef'},
{include: '#has'},
{include: '#ability'},
{include: '#general'}
]
},
ellipsis: {match: '\\.\\.\\.', name: 'constant.other.ellipsis.jac'},
'escape-sequence': {
match:
'(?x)\n \\\\ (\n x[0-9A-Fa-f]{2}\n | [0-7]{1,3}\n | [\\\\"\'abfnrtv]\n )\n',
name: 'constant.character.escape.jac'
},
'escape-sequence-unicode': {
patterns: [
{
match:
'(?x)\n \\\\ (\n u[0-9A-Fa-f]{4}\n | U[0-9A-Fa-f]{8}\n | N\\{[\\w\\s]+?\\}\n )\n',
name: 'constant.character.escape.jac'
}
]
},
expression: {
patterns: [
{include: '#expression-base'},
{include: '#member-access'},
{match: '(?x) \\b ([[:alpha:]_]\\w*) \\b'}
]
},
'expression-bare': {
patterns: [
{include: '#jsx'},
{include: '#illegal-anno'},
{include: '#literal'},
{include: '#regexp'},
{include: '#string'},
{include: '#lambda'},
{include: '#generator'},
{include: '#illegal-operator'},
{include: '#operator'},
{include: '#curly-braces'},
{include: '#item-access'},
{include: '#list'},
{include: '#odd-function-call'},
{include: '#round-braces'},
{include: '#function-call'},
{include: '#builtin-functions'},
{include: '#builtin-types'},
{include: '#builtin-exceptions'},
{include: '#magic-names'},
{include: '#special-names'},
{include: '#illegal-names'},
{include: '#special-variables'},
{include: '#ellipsis'},
{include: '#punctuation'},
{include: '#line-continuation'}
]
},
'expression-base': {
patterns: [
{include: '#comments'},
{include: '#expression-bare'},
{include: '#line-continuation'}
]
},
'f-expression': {
patterns: [
{include: '#expression-bare'},
{include: '#member-access'},
{match: '(?x) \\b ([[:alpha:]_]\\w*) \\b'}
]
},
'fregexp-base-expression': {
patterns: [
{include: '#fregexp-quantifier'},
{include: '#fstring-formatting-braces'},
{match: '\\{.*?\\}'},
{include: '#regexp-base-common'}
]
},
'fregexp-quantifier': {
match: '(?x)\n \\{\\{(\n \\d+ | \\d+,(\\d+)? | ,\\d+\n )\\}\\}\n',
name: 'keyword.operator.quantifier.regexp'
},
'fstring-fnorm-quoted-multi-line': {
begin: '(\\b[fF])([bBuU])?(\'\'\'|""")',
beginCaptures: {
1: {
name: 'string.interpolated.jac string.quoted.multi.jac storage.type.string.jac'
},
2: {name: 'invalid.illegal.prefix.jac'},
3: {
name: 'punctuation.definition.string.begin.jac string.interpolated.jac string.quoted.multi.jac'
}
},
end: '(\\3)',
endCaptures: {
1: {
name: 'punctuation.definition.string.end.jac string.interpolated.jac string.quoted.multi.jac'
},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'meta.fstring.jac',
patterns: [
{include: '#fstring-guts'},
{include: '#fstring-illegal-multi-brace'},
{include: '#fstring-multi-brace'},
{include: '#fstring-multi-core'}
]
},
'fstring-fnorm-quoted-single-line': {
begin: '(\\b[fF])([bBuU])?(([\'"]))',
beginCaptures: {
1: {
name: 'string.interpolated.jac string.quoted.single.jac storage.type.string.jac'
},
2: {name: 'invalid.illegal.prefix.jac'},
3: {
name: 'punctuation.definition.string.begin.jac string.interpolated.jac string.quoted.single.jac'
}
},
end: '(\\3)|((?<!\\\\)\\n)',
endCaptures: {
1: {
name: 'punctuation.definition.string.end.jac string.interpolated.jac string.quoted.single.jac'
},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'meta.fstring.jac',
patterns: [
{include: '#fstring-guts'},
{include: '#fstring-illegal-single-brace'},
{include: '#fstring-single-brace'},
{include: '#fstring-single-core'}
]
},
'fstring-formatting': {
patterns: [
{include: '#fstring-formatting-braces'},
{include: '#fstring-formatting-singe-brace'}
]
},
'fstring-formatting-braces': {
patterns: [
{
captures: {
1: {name: 'constant.character.format.placeholder.other.jac'},
2: {name: 'invalid.illegal.brace.jac'},
3: {name: 'constant.character.format.placeholder.other.jac'}
},
match: '({)(\\s*?)(})'
},
{match: '({{|}})', name: 'constant.character.escape.jac'}
]
},
'fstring-formatting-singe-brace': {
match: '(}(?!}))',
name: 'invalid.illegal.brace.jac'
},
'fstring-guts': {
patterns: [
{include: '#escape-sequence-unicode'},
{include: '#escape-sequence'},
{include: '#string-line-continuation'},
{include: '#fstring-formatting'}
]
},
'fstring-illegal-multi-brace': {patterns: [{include: '#impossible'}]},
'fstring-illegal-single-brace': {
begin: '(\\{)(?=[^\\n}]*$\\n?)',
beginCaptures: {
1: {name: 'constant.character.format.placeholder.other.jac'}
},
end: '(\\})|(?=\\n)',
endCaptures: {
1: {name: 'constant.character.format.placeholder.other.jac'}
},
patterns: [
{include: '#fstring-terminator-single'},
{include: '#f-expression'}
]
},
'fstring-multi-brace': {
begin: '(\\{)',
beginCaptures: {
1: {name: 'constant.character.format.placeholder.other.jac'}
},
end: '(?x)\n (\\})\n',
endCaptures: {
1: {name: 'constant.character.format.placeholder.other.jac'}
},
patterns: [
{include: '#fstring-terminator-multi'},
{include: '#f-expression'}
]
},
'fstring-multi-core': {
match:
'(?x)\n (.+?)\n (\n (?# .* and .*? in multi-line match need special handling of\n newlines otherwise SublimeText and Atom will match slightly\n differently.\n\n The guard for newlines has to be separate from the\n lookahead because of special $ matching rule.)\n ($\\n?)\n |\n (?=[\\\\\\}\\{]|\'\'\'|""")\n )\n (?# due to how multiline regexps are matched we need a special case\n for matching a newline character)\n | \\n\n',
name: 'string.interpolated.jac string.quoted.multi.jac'
},
'fstring-normf-quoted-multi-line': {
begin: '(\\b[bBuU])([fF])(\'\'\'|""")',
beginCaptures: {
1: {name: 'invalid.illegal.prefix.jac'},
2: {
name: 'string.interpolated.jac string.quoted.multi.jac storage.type.string.jac'
},
3: {
name: 'punctuation.definition.string.begin.jac string.quoted.multi.jac'
}
},
end: '(\\3)',
endCaptures: {
1: {
name: 'punctuation.definition.string.end.jac string.interpolated.jac string.quoted.multi.jac'
},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'meta.fstring.jac',
patterns: [
{include: '#fstring-guts'},
{include: '#fstring-illegal-multi-brace'},
{include: '#fstring-multi-brace'},
{include: '#fstring-multi-core'}
]
},
'fstring-normf-quoted-single-line': {
begin: '(\\b[bBuU])([fF])(([\'"]))',
beginCaptures: {
1: {name: 'invalid.illegal.prefix.jac'},
2: {
name: 'string.interpolated.jac string.quoted.single.jac storage.type.string.jac'
},
3: {
name: 'punctuation.definition.string.begin.jac string.quoted.single.jac'
}
},
end: '(\\3)|((?<!\\\\)\\n)',
endCaptures: {
1: {
name: 'punctuation.definition.string.end.jac string.interpolated.jac string.quoted.single.jac'
},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'meta.fstring.jac',
patterns: [
{include: '#fstring-guts'},
{include: '#fstring-illegal-single-brace'},
{include: '#fstring-single-brace'},
{include: '#fstring-single-core'}
]
},
'fstring-raw-guts': {
patterns: [
{include: '#string-consume-escape'},
{include: '#fstring-formatting'}
]
},
'fstring-raw-multi-core': {
match:
'(?x)\n (.+?)\n (\n (?# .* and .*? in multi-line match need special handling of\n newlines otherwise SublimeText and Atom will match slightly\n differently.\n\n The guard for newlines has to be separate from the\n lookahead because of special $ matching rule.)\n ($\\n?)\n |\n (?=[\\\\\\}\\{]|\'\'\'|""")\n )\n (?# due to how multiline regexps are matched we need a special case\n for matching a newline character)\n | \\n\n',
name: 'string.interpolated.jac string.quoted.raw.multi.jac'
},
'fstring-raw-quoted-multi-line': {
begin: '(\\b(?:[rR][fF]|[fF][rR]))(\'\'\'|""")',
beginCaptures: {
1: {
name: 'string.interpolated.jac string.quoted.raw.multi.jac storage.type.string.jac'
},
2: {
name: 'punctuation.definition.string.begin.jac string.quoted.raw.multi.jac'
}
},
end: '(\\2)',
endCaptures: {
1: {
name: 'punctuation.definition.string.end.jac string.interpolated.jac string.quoted.raw.multi.jac'
},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'meta.fstring.jac',
patterns: [
{include: '#fstring-raw-guts'},
{include: '#fstring-illegal-multi-brace'},
{include: '#fstring-multi-brace'},
{include: '#fstring-raw-multi-core'}
]
},
'fstring-raw-quoted-single-line': {
begin: '(\\b(?:[rR][fF]|[fF][rR]))(([\'"]))',
beginCaptures: {
1: {
name: 'string.interpolated.jac string.quoted.raw.single.jac storage.type.string.jac'
},
2: {
name: 'punctuation.definition.string.begin.jac string.quoted.raw.single.jac'
}
},
end: '(\\2)|((?<!\\\\)\\n)',
endCaptures: {
1: {
name: 'punctuation.definition.string.end.jac string.interpolated.jac string.quoted.raw.single.jac'
},
2: {name: 'invalid.illegal.newline.jac'}
},
name: 'meta.fstring.jac',
patterns: [
{include: '#fstring-raw-guts'},
{include: '#fstring-illegal-single-brace'},
{include: '#fstring-single-brace'},
{include: '#fstring-raw-single-core'}
]
},
'fstring-raw-single-core': {
match:
'(?x)\n (.+?)\n (\n (?# .* and .*? in multi-line match need special handling of\n newlines otherwise SublimeText and Atom will match slightly\n differently.\n\n The guard for newlines has to be separate from the\n lookahead because of special $ matching rule.)\n ($\\n?)\n |\n (?=[\\\\\\}\\{]|([\'"])|((?<!\\\\)\\n))\n )\n (?# due to how multiline regexps are matched we need a special case\n for matching a newline character)\n | \\n\n',
name: 'string.interpolated.jac string.quoted.raw.single.jac'
},
'fstring-single-brace': {
begin: '(\\{)',
beginCaptures: {
1: {name: 'constant.character.format.placeholder.other.jac'}
},
end: '(?x)\n (\\})|(?=\\n)\n',
endCaptures: {
1: {name: 'constant.character.format.placeholder.other.jac'}
},
patterns: [
{include: '#fstring-terminator-single'},
{include: '#f-expression'}
]
},
'fstring-single-core': {
match:
'(?x)\n (.+?)\n (\n (?# .* and .*? in multi-line match need special handling of\n newlines otherwise SublimeText and Atom will match slightly\n differently.\n\n The guard for newlines has to be separate from the\n lookahead because of special $ matching rule.)\n ($\\n?)\n |\n (?=[\\\\\\}\\{]|([\'"])|((?<!\\\\)\\n))\n )\n (?# due to how multiline regexps are matched we need a special case\n for matching a newline character)\n | \\n\n',
name: 'string.interpolated.jac string.quoted.single.jac'
},
'fstring-terminator-multi': {
patterns: [
{match: '(=(![rsa])?)(?=})', name: 'storage.type.format.jac'},
{match: '(=?![rsa])(?=})', name: 'storage.type.format.jac'},
{
captures: {
1: {name: 'storage.type.format.jac'},
2: {name: 'storage.type.format.jac'}
},
match:
'(?x)\n ( (?: =?) (?: ![rsa])? )\n ( : \\w? [<>=^]? [-+ ]? \\#?\n \\d* ,? (\\.\\d+)? [bcdeEfFgGnosxX%]? )(?=})\n'
},
{include: '#fstring-terminator-multi-tail'}
]
},
'fstring-terminator-multi-tail': {
begin: '((?:=?)(?:![rsa])?)(:)(?=.*?{)',
beginCaptures: {
1: {name: 'storage.type.format.jac'},
2: {name: 'storage.type.format.jac'}
},
end: '(?=})',
patterns: [
{include: '#fstring-illegal-multi-brace'},
{include: '#fstring-multi-brace'},
{match: '([bcdeEfFgGnosxX%])(?=})', name: 'storage.type.format.jac'},
{match: '(\\.\\d+)', name: 'storage.type.format.jac'},
{match: '(,)', name: 'storage.type.format.jac'},
{match: '(\\d+)', name: 'storage.type.format.jac'},
{match: '(\\#)', name: 'storage.type.format.jac'},
{match: '([-+ ])', name: 'storage.type.format.jac'},
{match: '([<>=^])', name: 'storage.type.format.jac'},
{match: '(\\w)', name: 'storage.type.format.jac'}
]
},
'fstring-terminator-single': {
patterns: [
{match: '(=(![rsa])?)(?=})', name: 'storage.type.format.jac'},
{match: '(=?![rsa])(?=})', name: 'storage.type.format.jac'},
{
captures: {
1: {name: 'storage.type.format.jac'},
2: {name: 'storage.type.format.jac'}
},
match:
'(?x)\n ( (?: =?) (?: ![rsa])? )\n ( : \\w? [<>=^]? [-+ ]? \\#?\n \\d* ,? (\\.\\d+)? [bcdeEfFgGnosxX%]? )(?=})\n'
},
{include: '#fstring-terminator-single-tail'}
]
},
'fstring-terminator-single-tail': {
begin: '((?:=?)(?:![rsa])?)(:)(?=.*?{)',
beginCaptures: {
1: {name: 'storage.type.format.jac'},
2: {name: 'storage.type.format.jac'}
},
end: '(?=})|(?=\\n)',
patterns: [
{include: '#fstring-illegal-single-brace'},
{include: '#fstring-single-brace'},
{match: '([bcdeEfFgGnosxX%])(?=})', name: 'storage.type.format.jac'},
{match: '(\\.\\d+)', name: 'storage.type.format.jac'},
{match: '(,)', name: 'storage.type.format.jac'},
{match: '(\\d+)', name: 'storage.type.format.jac'},
{match: '(\\#)', name: 'storage.type.format.jac'},
{match: '([-+ ])', name: 'storage.type.format.jac'},
{match: '([<>=^])', name: 'storage.type.format.jac'},
{match: '(\\w)', name: 'storage.type.format.jac'}
]
},
'function-arguments': {
begin: '(\\()',
beginCaptures: {1: {name: 'punctuation.definition.arguments.begin.jac'}},
contentName: 'meta.function-call.arguments.jac',
end: '(?=\\))(?!\\)\\s*\\()',
patterns: [
{match: '(,)', name: 'punctuation.separator.arguments.jac'},
{
captures: {1: {name: 'keyword.operator.unpacking.arguments.jac'}},
match: '(?x)\n (?:(?<=[,(])|^) \\s* (\\*{1,2})\n'
},
{include: '#lambda-incomplete'},
{include: '#illegal-names'},
{
captures: {
1: {name: 'variable.parameter.function-call.jac'},
2: {name: 'keyword.operator.assignment.jac'}
},
match: '\\b([[:alpha:]_]\\w*)\\s*(=)(?!=)'
},
{match: '=(?!=)', name: 'keyword.operator.assignment.jac'},
{include: '#expression'},
{
captures: {
1: {name: 'punctuation.definition.arguments.end.jac'},
2: {name: 'punctuation.definition.arguments.begin.jac'}
},
match: '\\s*(\\))\\s*(\\()'
}
]
},
'function-call': {
begin: '(?x)\n \\b(?=\n ([[:alpha:]_]\\w*) \\s* (\\()\n )\n',
end: '(\\))',
endCaptures: {1: {name: 'punctuation.definition.arguments.end.jac'}},
name: 'meta.function-call.jac',
patterns: [
{include: '#special-variables'},
{include: '#function-name'},
{include: '#function-arguments'}
]
},
'function-declaration': {
begin:
'(?x)\n \\s*\n (?:\\b(async) \\s+)? \\b(def)\\s+\n (?=\n [[:alpha:]_][[:word:]]* \\s* \\(\n )\n',
beginCaptures: {
1: {name: 'storage.type.function.async.jac'},
2: {name: 'storage.type.function.jac'}
},
end: '(:|(?=[#\'"\\n]))',
endCaptures: {1: {name: 'punctuation.section.function.begin.jac'}},
name: 'meta.function.jac',
patterns: [
{include: '#function-def-name'},
{include: '#parameters'},
{include: '#line-continuation'},
{include: '#return-annotation'}
]
},
'function-def-name': {
patterns: [
{include: '#illegal-object-name'},
{include: '#builtin-possible-callables'},
{
match: '(?x)\n \\b ([[:alpha:]_]\\w*) \\b\n',
name: 'entity.name.function.jac'
}
]
},
'function-name': {
patterns: [
{include: '#builtin-possible-callables'},
{
match: '(?x)\n \\b ([[:alpha:]_]\\w*) \\b\n',
name: 'meta.function-call.generic.jac'
}
]
},
general: {
patterns: [
{include: '#comments'},
{include: '#builtin-types'},
{include: '#special-variables'},
{include: '#statement-keyword'},
{include: '#function-call'},
{include: '#jsx'},
{include: '#literal'},
{include: '#operator'},
{include: '#assignment-operator'},
{include: '#docstring-statement'},
{include: '#string'}
]
},
generator: {
begin: '\\bfor\\b',
beginCaptures: {0: {name: 'keyword.control.flow.jac'}},
end: '\\bin\\b',
endCaptures: {0: {name: 'keyword.control.flow.jac'}},
patterns: [{include: '#expression'}]
},
global: {
patterns: [
{
begin: '(?x)\\b(glob|let)\\b(?=\\s*[[:alpha:]_]\\w*|\\s*\\n)',
beginCaptures: {1: {name: 'storage.type.variable.jac'}},
end: ';',
endCaptures: {1: {name: 'punctuation.section.class.begin.jac'}},
name: 'meta.property.jac',
patterns: [
{include: '#comments'},
{match: ',', name: 'punctuation.separator.jac'},
{include: '#general'},
{
match: '\\b([[:alpha:]_]\\w*)\\s*(?=\\=)',
name: 'entity.name.type.property.jac'
}
]
}
]
},
has: {
patterns: [
{
begin: '(?x)\\b(has)\\b(?=\\s*[[:alpha:]_]\\w*|\\s*({|;|\\(||\\n))',
beginCaptures: {1: {name: 'storage.type.function.jac'}},
end: '(?=\\)|{)|;|by',
endCaptures: {1: {name: 'punctuation.section.function.begin.jac'}},
name: 'meta.property.jac',
patterns: [
{include: '#comments'},
{match: ',', name: 'punctuation.separator.jac'},
{include: '#general'},
{
captures: {
1: {name: 'variable.parameter.language.jac'},
2: {name: 'punctuation.separator.parameters.jac'}
},
match: '(?x)\n ([[:alpha:]_]\\w*)\n \\s* (?: (:) )\n'
},
{include: '#builtin-types'},
{include: '#statement-keyword'},
{
match: '(?x)\n \\b ([[:alpha:]_]\\w*) \\b\n',
name: 'entity.name.type.property.jac'
}
]
}
]
},
'illegal-anno': {match: '->', name: 'invalid.illegal.annotation.jac'},
'illegal-names': {
captures: {
1: {name: 'keyword.control.flow.jac'},
2: {name: 'keyword.control.import.jac'}
},
match:
'(?x)\n \\b(?:\n (\n and | assert | check | async | await | break | class | continue | def\n | del | elif | else | except | finally | for | from | global\n | if | in | is | (?<=\\.)lambda | lambda(?=\\s*[\\.=])\n | nonlocal | not | or | pass | raise | return | try | while | with\n | yield\n ) | (\n as | import\n )\n )\\b\n'
},
'illegal-object-name': {
match: '\\b(True|False|None)\\b',
name: 'keyword.illegal.name.jac'
},
'illegal-operator': {
patterns: [
{match: '&&|\\|\\||--|\\+\\+', name: 'invalid.illegal.operator.jac'},
{match: '!\\b', name: 'invalid.illegal.operator.jac'}
]
},
import: {
patterns: [
{
begin: '\\b(?<!\\.)(import|include)\\b',
beginCaptures: {1: {name: 'keyword.control.import.jac'}},
end: ';|}',
patterns: [
{include: '#comments'},
{
match: '\\b(?<!\\.)(as|from)\\b',
name: 'keyword.control.import.jac'
},
{match: ',|:', name: 'punctuation.separator.jac'},
{
match: '\\b(?<!\\.)(py|jac)\\b',
name: 'variable.language.special.self.jac'
},
{
match: '\\b(?<!:)([[:alpha:]_]\\w*)\\b',
name: 'entity.name.namespace.jac'
}
]
}
]
},
'inheritance-identifier': {
captures: {1: {name: 'entity.other.inherited-class.jac'}},
match: '(?x)\n \\b ([[:alpha:]_]\\w*) \\b\n'
},
'inheritance-name': {
patterns: [
{include: '#lambda-incomplete'},
{include