From 2f4f4645a783d6fc4010bf285f7be678fb18aa90 Mon Sep 17 00:00:00 2001 From: Matthias Date: Mon, 13 May 2019 20:14:49 -0700 Subject: [PATCH 1/5] Clone JSX --- Packages/JSX/Default.sublime-keymap | 62 + Packages/JSX/JSX (Inner).YAML-tmPreferences | 9 + Packages/JSX/JSX (Inner).tmPreferences | 28 + Packages/JSX/JSX (Outer).YAML-tmPreferences | 16 + Packages/JSX/JSX (Outer).tmPreferences | 21 + .../JSX/JavaScript (Babel).YAML-tmLanguage | 1467 ++++++ Packages/JSX/JavaScript (Babel).tmLanguage | 4003 +++++++++++++++++ Packages/JSX/LICENSE | 22 + Packages/JSX/Next.YAML-tmTheme | 854 ++++ Packages/JSX/Next.tmTheme | 1868 ++++++++ Packages/JSX/README.md | 67 + Packages/JSX/Styled Components.tmLanguage | 542 +++ Packages/JSX/messages.json | 8 + Packages/JSX/messages/3.0.0.txt | 4 + Packages/JSX/messages/4.0.0.txt | 4 + Packages/JSX/messages/5.0.0.txt | 11 + Packages/JSX/messages/7.1.0.txt | 28 + Packages/JSX/messages/8.0.0.txt | 14 + Packages/JSX/messages/9.0.0.txt | 8 + Packages/JSX/package.json | 4 + .../compare-jsx-comments-etc@2x.png | Bin 0 -> 37079 bytes .../screenshots/compare-jsx-illegal@2x.png | Bin 0 -> 30862 bytes .../JSX/screenshots/compare-jsx-tight@2x.png | Bin 0 -> 24980 bytes .../screenshots/compare-react-class@2x.png | Bin 0 -> 57670 bytes Packages/JSX/screenshots/oceanic-next.png | Bin 0 -> 59838 bytes Packages/JSX/test/syntax_test_issues_OLD.js | 275 ++ Packages/JSX/test/syntax_test_js_babel_OLD.js | 3187 +++++++++++++ Packages/JSX/test/syntax_test_jsx_OLD.js | 767 ++++ .../JSX/test/syntax_test_jsx_invalid_OLD.js | 231 + .../JSX/test/syntax_test_react_class_OLD.js | 485 ++ .../JSX/test/syntax_test_relational_OLD.js | 289 ++ Packages/JSX/test/syntax_test_styles.js | 96 + 32 files changed, 14370 insertions(+) create mode 100644 Packages/JSX/Default.sublime-keymap create mode 100644 Packages/JSX/JSX (Inner).YAML-tmPreferences create mode 100644 Packages/JSX/JSX (Inner).tmPreferences create mode 100644 Packages/JSX/JSX (Outer).YAML-tmPreferences create mode 100644 Packages/JSX/JSX (Outer).tmPreferences create mode 100644 Packages/JSX/JavaScript (Babel).YAML-tmLanguage create mode 100644 Packages/JSX/JavaScript (Babel).tmLanguage create mode 100644 Packages/JSX/LICENSE create mode 100644 Packages/JSX/Next.YAML-tmTheme create mode 100644 Packages/JSX/Next.tmTheme create mode 100644 Packages/JSX/README.md create mode 100644 Packages/JSX/Styled Components.tmLanguage create mode 100644 Packages/JSX/messages.json create mode 100644 Packages/JSX/messages/3.0.0.txt create mode 100644 Packages/JSX/messages/4.0.0.txt create mode 100644 Packages/JSX/messages/5.0.0.txt create mode 100644 Packages/JSX/messages/7.1.0.txt create mode 100644 Packages/JSX/messages/8.0.0.txt create mode 100644 Packages/JSX/messages/9.0.0.txt create mode 100644 Packages/JSX/package.json create mode 100644 Packages/JSX/screenshots/compare-jsx-comments-etc@2x.png create mode 100644 Packages/JSX/screenshots/compare-jsx-illegal@2x.png create mode 100644 Packages/JSX/screenshots/compare-jsx-tight@2x.png create mode 100644 Packages/JSX/screenshots/compare-react-class@2x.png create mode 100644 Packages/JSX/screenshots/oceanic-next.png create mode 100644 Packages/JSX/test/syntax_test_issues_OLD.js create mode 100644 Packages/JSX/test/syntax_test_js_babel_OLD.js create mode 100644 Packages/JSX/test/syntax_test_jsx_OLD.js create mode 100644 Packages/JSX/test/syntax_test_jsx_invalid_OLD.js create mode 100644 Packages/JSX/test/syntax_test_react_class_OLD.js create mode 100644 Packages/JSX/test/syntax_test_relational_OLD.js create mode 100644 Packages/JSX/test/syntax_test_styles.js diff --git a/Packages/JSX/Default.sublime-keymap b/Packages/JSX/Default.sublime-keymap new file mode 100644 index 0000000..f890840 --- /dev/null +++ b/Packages/JSX/Default.sublime-keymap @@ -0,0 +1,62 @@ +[ + // Auto-pair backticks + { "keys": ["`"], "command": "insert_snippet", "args": {"contents": "`$0`"}, "context": + [ + { "key": "selector", "operator": "equal", "operand": "source.js", "match_all": true }, + { "key": "setting.auto_match_enabled", "operator": "equal", "operand": true }, + { "key": "selection_empty", "operator": "equal", "operand": true, "match_all": true }, + { "key": "following_text", "operator": "regex_contains", "operand": "^(?:\t| |\\)|]|\\}|>|$)", "match_all": true }, + { "key": "preceding_text", "operator": "not_regex_contains", "operand": "[`a-zA-Z0-9_]$", "match_all": true }, + { "key": "eol_selector", "operator": "not_equal", "operand": "string.quoted.template", "match_all": true } + ] + }, + { "keys": ["`"], "command": "insert_snippet", "args": {"contents": "`${0:$SELECTION}`"}, "context": + [ + { "key": "selector", "operator": "equal", "operand": "source.js", "match_all": true }, + { "key": "setting.auto_match_enabled", "operator": "equal", "operand": true }, + { "key": "selection_empty", "operator": "equal", "operand": false, "match_all": true } + ] + }, + { "keys": ["`"], "command": "move", "args": {"by": "characters", "forward": true}, "context": + [ + { "key": "selector", "operator": "equal", "operand": "source.js", "match_all": true }, + { "key": "setting.auto_match_enabled", "operator": "equal", "operand": true }, + { "key": "selection_empty", "operator": "equal", "operand": true, "match_all": true }, + { "key": "following_text", "operator": "regex_contains", "operand": "^`", "match_all": true } + ] + }, + + // Auto-pair interpolation + { "keys": ["{"], "command": "insert_snippet", "args": {"contents": "{$0}"}, "context": + [ + { "key": "setting.auto_match_enabled", "operator": "equal", "operand": true }, + { "key": "selection_empty", "operator": "equal", "operand": true, "match_all": true }, + { "key": "selector", "operator": "equal", "operand": "source.js string.template.js - meta.template.expression.js", "match_all": true }, + { "key": "preceding_text", "operator": "regex_contains", "operand": "\\$$", "match_all": true } + ] + }, + { "keys": ["$"], "command": "insert_snippet", "args": {"contents": "\\${${0:$SELECTION}}"}, "context": + [ + { "key": "selector", "operator": "equal", "operand": "source.js string.template.js - meta.template.expression.js", "match_all": true }, + { "key": "setting.auto_match_enabled", "operator": "equal", "operand": true }, + { "key": "selection_empty", "operator": "equal", "operand": false, "match_all": true } + ] + }, + + // JSX close tag (inside JSX) + { "keys": ["/"], "command": "close_tag", "args": { "insert_slash": true }, "context": + [ + { "key": "selector", "operator": "equal", "operand": "source.js meta.jsx.js - meta.embedded.expression - string - comment", "match_all": true }, + { "key": "preceding_text", "operator": "regex_match", "operand": ".*<$", "match_all": true }, + { "key": "setting.auto_close_tags" } + ] + }, + // JSX close tag (outer-most tag) + { "keys": ["/"], "command": "close_tag", "args": { "insert_slash": true }, "context": + [ + { "key": "selector", "operator": "equal", "operand": "source.js - string - comment", "match_all": true }, + { "key": "preceding_text", "operator": "regex_match", "operand": "^\\s*<$", "match_all": true }, + { "key": "setting.auto_close_tags" } + ] + } +] diff --git a/Packages/JSX/JSX (Inner).YAML-tmPreferences b/Packages/JSX/JSX (Inner).YAML-tmPreferences new file mode 100644 index 0000000..f68bfad --- /dev/null +++ b/Packages/JSX/JSX (Inner).YAML-tmPreferences @@ -0,0 +1,9 @@ +# [PackageDev] target_format: plist, ext: tmPreferences +name: JSX +scope: source.js meta.jsx.js - meta.embedded.expression +settings: + shellVariables: + - name: TM_COMMENT_START + value: '{/*' + - name: TM_COMMENT_END + value: '*/}' diff --git a/Packages/JSX/JSX (Inner).tmPreferences b/Packages/JSX/JSX (Inner).tmPreferences new file mode 100644 index 0000000..168af83 --- /dev/null +++ b/Packages/JSX/JSX (Inner).tmPreferences @@ -0,0 +1,28 @@ + + + + + name + JSX + scope + source.js meta.jsx.js - meta.embedded.expression + settings + + shellVariables + + + name + TM_COMMENT_START + value + {/* + + + name + TM_COMMENT_END + value + */} + + + + + diff --git a/Packages/JSX/JSX (Outer).YAML-tmPreferences b/Packages/JSX/JSX (Outer).YAML-tmPreferences new file mode 100644 index 0000000..d1e3052 --- /dev/null +++ b/Packages/JSX/JSX (Outer).YAML-tmPreferences @@ -0,0 +1,16 @@ +# [PackageDev] target_format: plist, ext: tmPreferences +name: JSX 2 +scope: source.js +settings: + # The indent patterns can't be limited to meta.jsx.js. Otherwise they wouldn't + # work for the outer most tag since it would fall outside of that scope. + # They're also not limited with '- string - comment' since you may be writing + # JSX in your documentation or template strings. + decreaseIndentPattern: >- + (?x) + ^\s*]+>$ + | ^\s*/>$ + increaseIndentPattern: >- + (?x) + ^\s*<[^/>]+>$ + | ^\s*<[^/>\s]+$ diff --git a/Packages/JSX/JSX (Outer).tmPreferences b/Packages/JSX/JSX (Outer).tmPreferences new file mode 100644 index 0000000..788984b --- /dev/null +++ b/Packages/JSX/JSX (Outer).tmPreferences @@ -0,0 +1,21 @@ + + + + + name + JSX 2 + scope + source.js + settings + + decreaseIndentPattern + (?x) + ^\s*</[^>]+>$ + | ^\s*/>$ + increaseIndentPattern + (?x) + ^\s*<[^/>]+>$ + | ^\s*<[^/>\s]+$ + + + diff --git a/Packages/JSX/JavaScript (Babel).YAML-tmLanguage b/Packages/JSX/JavaScript (Babel).YAML-tmLanguage new file mode 100644 index 0000000..0b2a492 --- /dev/null +++ b/Packages/JSX/JavaScript (Babel).YAML-tmLanguage @@ -0,0 +1,1467 @@ +# [PackageDev] target_format: plist, ext: tmLanguage +name: JavaScript (Babel) +scopeName: source.js +fileTypes: [js, jsx, babel, es6] +firstLineMatch: ^#!\s*/.*\b(node|js)$\n? + +patterns: +- include: '#core' + +repository: + core: + patterns: + - include: '#literal-function-labels' + - include: '#literal-arrow-function-labels' + - include: '#literal-labels' + + - include: '#literal-for' + - include: '#literal-switch' + + - include: '#styled-components' # add support for styled-components + - include: '#graphql' + + - include: '#expression' + - include: '#literal-punctuation' + + expression: + patterns: + - include: '#merge-conflits' + - include: '#literal-regexp' # before operators and keywords to avoid ambiguities + - include: '#literal-jsx' + - include: '#es7-decorators' + - include: '#support-class' + - include: '#support-other' + + - include: '#literal-function' + - include: '#literal-arrow-function' + - include: '#literal-prototype' # after literal-function, which includes some prototype strings + + - include: '#literal-keywords' + + - include: '#literal-method' + - include: '#literal-module' + - include: '#literal-class' + - include: '#flowtype-declaration' + + - include: '#literal-number' # after literal-method since short methods can be numbers + - include: '#literal-template-string' + - include: '#literal-string' + - include: '#literal-language-constant' + - include: '#literal-language-variable' + + - include: '#literal-constructor' + - include: '#literal-method-call' + - include: '#literal-function-call' + + - include: '#comments' + - include: '#brackets' + + - include: '#literal-operators' + - include: '#literal-variable' + + round-brackets: + patterns: + - name: meta.group.braces.round.js + begin: \( + beginCaptures: + '0': {name: meta.brace.round.begin.js} + end: \) + endCaptures: + '0': {name: meta.brace.round.end.js} + patterns: + - include: '#expression' + + square-brackets: + patterns: + - name: meta.group.braces.square.js + begin: \[ + beginCaptures: + '0': {name: meta.brace.square.begin.js} + end: \] + endCaptures: + '0': {name: meta.brace.square.end.js} + patterns: + - include: '#expression' + + curly-brackets: + patterns: + - name: meta.group.braces.curly.js + begin: '{' + beginCaptures: + '0': {name: meta.brace.curly.begin.js} + end: '}' + endCaptures: + '0': {name: meta.brace.curly.end.js} + patterns: + - include: $self + + brackets: + patterns: + - include: '#round-brackets' + - include: '#square-brackets' + - include: '#curly-brackets' + + comments: + patterns: + - name: comment.block.documentation.js + begin: /\*\*(?!/) + captures: + '0': {name: punctuation.definition.comment.js} + end: \*/ + + - name: comment.block.js + begin: /\* + beginCaptures: + '0': {name: punctuation.definition.comment.begin.js} + end: \*/ + endCaptures: + '0': {name: punctuation.definition.comment.end.js} + + - name: comment.block.html.js + match: (?>) + captures: + '0': {name: punctuation.definition.comment.js} + + - name: comment.line.double-slash.js + match: (//).*$\n? + captures: + '1': {name: punctuation.definition.comment.js} + + - name: comment.line.shebang.js + match: ^(#!).*$\n? + captures: + '1': {name: punctuation.definition.comment.js} + + function-declaration-parameters: + patterns: + - begin: \( + beginCaptures: + '0': {name: punctuation.definition.parameters.begin.js} + end: \) + endCaptures: + '0': {name: punctuation.definition.parameters.end.js} + patterns: + - include: '#comments' + - include: '#flowtype-annotation' + - name: keyword.operator.spread.js + match: (?import|export|default|from|as)\b + + literal-class: + patterns: + # e.g. class MyClass { } + - name: meta.class.js + begin: (?; + # e.g. static (o: ?void): {[key: any]: any}; + # e.g. return(value: R): { done: true, value: R }; + # e.g. (o: T): T; + - name: meta.short-method.flowtype.js + begin: (@@[_$a-zA-Z][$\w]*|static|return)(?=\s*[<(])|(?=\s*<) + beginCaptures: + '1': {name: keyword.operator.flowtype.js} + end: (?=\s*[;{]) + patterns: + - include: '#flowtype-polymorph' + - include: '#function-declaration-parameters' + - include: '#flowtype-annotation' + - include: '#comments' + - include: '#curly-brackets' + + # In objects and flow annotations it can't be assumed that a start quote + # or start square-bracket is for a method - it may be a computed property. + # For multi-line quoted short methods and computed property methods, only + # the polymorphism constraints and parameters are matched. + - name: meta.class-method.computed.js + begin: (?<=[]"'])\s*(?=[<(]) + end: (?=\s*[;{]) + patterns: + - include: '#flowtype-polymorph' + - include: '#function-declaration-parameters' + - include: '#flowtype-annotation' + - include: '#comments' + - include: '#curly-brackets' + + - name: meta.class-accessor.js + begin: >- + (?x) + ((?>get|set)\s+) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + )(?=\s*[<(]) + beginCaptures: + '1': {name: storage.type.js} + '2': {name: string.quoted.js} + '3': {name: punctuation.definition.string.begin.js} + '4': {name: entity.name.function.js} + '5': {name: punctuation.definition.string.end.js} + '6': {name: string.quoted.js} + '7': {name: punctuation.definition.string.begin.js} + '8': {name: entity.name.function.js} + '9': {name: punctuation.definition.string.end.js} + '10': {name: string.unquoted.js} + '11': {name: entity.name.function.js} + end: (?=\s*[;{]) + patterns: + - include: '#flowtype-polymorph' + - include: '#function-declaration-parameters' + - include: '#flowtype-annotation' + - include: '#comments' + - include: '#curly-brackets' + + - name: meta.class-method.js + begin: >- + (?x) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + )(?=\s*[<(]) + beginCaptures: + '1': {name: string.quoted.js} + '2': {name: punctuation.definition.string.begin.js} + '3': {name: entity.name.function.js} + '4': {name: punctuation.definition.string.end.js} + '5': {name: string.quoted.js} + '6': {name: punctuation.definition.string.begin.js} + '7': {name: entity.name.function.js} + '8': {name: punctuation.definition.string.end.js} + '9': {name: string.unquoted.js} + '10': {name: entity.name.function.js} + end: (?=\s*[;{]) + patterns: + - include: '#flowtype-polymorph' + - include: '#function-declaration-parameters' + - include: '#flowtype-annotation' + - include: '#comments' + - include: '#curly-brackets' + + class-method-storage: + patterns: + - name: storage.modifier.js + match: (?static|declare)\b + + - name: storage.type.js + match: (?- + (?x) + (?:\b(static)\s+)? + (?:\b(async)\s+)? + (?:(\*)\s*)? + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + ) + (?=\s*(\((?>(?>[^()]+)|\g<-1>)*\))(?>\s|/\*.*\*/)*\{) + beginCaptures: + '1': {name: storage.type.js} + '2': {name: storage.type.js} + '3': {name: keyword.generator.asterisk.js} + '4': {name: string.quoted.js} + '5': {name: punctuation.definition.string.begin.js} + '6': {name: entity.name.function.js} + '7': {name: punctuation.definition.string.end.js} + '8': {name: string.quoted.js} + '9': {name: punctuation.definition.string.begin.js} + '10': {name: entity.name.function.js} + '11': {name: punctuation.definition.string.end.js} + '12': {name: string.unquoted.js} + '13': {name: entity.name.function.js} + end: (?<=\)) + patterns: + - include: '#function-declaration-parameters' + + # getter/setter + - name: meta.accessor.js + begin: >- + (?x) + \b(?:(static)\s+)? + (get|set)\s+ + ([_$a-zA-Z][$\w]*|\d+)\s* + (?=(\((?>(?>[^()]+)|\g<-1>)*\))(?>\s|/\*.*\*/)*\{) + beginCaptures: + '1': {name: storage.type.js} + '2': {name: storage.type.accessor.js} + '3': {name: entity.name.accessor.js} + end: (?<=\)) + patterns: + - include: '#function-declaration-parameters' + + literal-prototype: + patterns: + # e.g. Sound.prototype = { } when extending an object + - name: meta.prototype.declaration.js + match: ([_$a-zA-Z][$\w]*)(\.)(prototype)\s*(=)\s* + captures: + '1': {name: entity.name.class.js} + '2': {name: keyword.operator.accessor.js} + '3': {name: variable.language.prototype.js} + '4': {name: keyword.operator.assignment.js} + + # e.g. Sound.prototype + - name: meta.prototype.access.js + match: ([_$a-zA-Z][$\w]*)(\.)(prototype)\b + captures: + '1': {name: entity.name.class.js} + '2': {name: keyword.operator.accessor.js} + '3': {name: variable.language.prototype.js} + + literal-function: + patterns: + # e.g. function play(arg1, arg2) { } + # e.g. play = function(arg1, arg2) { } + - name: meta.function.js + begin: >- + (?x) + (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? + (?:(async)\s+)? + (function)(?>\s*(\*)|(?=[\s(<])) + \s*([_$a-zA-Z][$\w]*)? + beginCaptures: + '1': {name: entity.name.function.js} + '2': {name: keyword.operator.assignment.js} + '3': {name: storage.type.js} + '4': {name: storage.type.function.js} + '5': {name: keyword.generator.asterisk.js} + '6': {name: entity.name.function.js} + end: (?<=\)) + patterns: + - include: '#flowtype-polymorph' + - include: '#function-declaration-parameters' + + # e.g. Sound.prototype.play = function(arg1, arg2) { } + - name: meta.function.prototype.js + begin: >- + (?x) + (\b_?[A-Z][$\w]*)? + (\.)(prototype) + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(?:(async)\s+)? + \s*(function)(?>\s*(\*)|(?=[\s(<])) + \s*([_$a-zA-Z][$\w]*)?\s* + beginCaptures: + '1': {name: entity.name.class.js} + '2': {name: keyword.operator.accessor.js} + '3': {name: variable.language.prototype.js} + '4': {name: keyword.operator.accessor.js} + '5': {name: entity.name.function.js} + '6': {name: keyword.operator.assignment.js} + '7': {name: storage.type.js} + '8': {name: storage.type.function.js} + '9': {name: keyword.generator.asterisk.js} + '10': {name: entity.name.function.js} + end: (?<=\)) + patterns: + - include: '#flowtype-polymorph' + - include: '#function-declaration-parameters' + + # e.g. Sound.play = function(arg1, arg2) { } + - name: meta.function.static.js + begin: >- + (?x) + (\b_?[A-Z][$\w]*)? + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(?:(async)\s+)? + \s*(function)(?>\s*(\*)|(?=[\s(<])) + \s*([_$a-zA-Z][$\w]*)?\s* + beginCaptures: + '1': {name: entity.name.class.js} + '2': {name: keyword.operator.accessor.js} + '3': {name: entity.name.function.js} + '4': {name: keyword.operator.assignment.js} + '5': {name: storage.type.js} + '6': {name: storage.type.function.js} + '7': {name: keyword.generator.asterisk.js} + '8': {name: entity.name.function.js} + end: (?<=\)) + patterns: + - include: '#flowtype-polymorph' + - include: '#function-declaration-parameters' + + literal-function-labels: + patterns: + # e.g. play: function(arg1, arg2) { } + # e.g. "play": function(arg1, arg2) { } + - name: meta.function.json.js + begin: >- + (?x) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + ) + \s*(:) + \s*(?:\b(async)\s+)? + \s*(function)(?>\s*(\*)|(?=[\s(<])) + \s*([_$a-zA-Z][$\w]*)? + beginCaptures: + '1': {name: string.quoted.js} + '2': {name: punctuation.definition.string.begin.js} + '3': {name: entity.name.function.js} + '4': {name: punctuation.definition.string.end.js} + '5': {name: string.quoted.js} + '6': {name: punctuation.definition.string.begin.js} + '7': {name: entity.name.function.js} + '8': {name: punctuation.definition.string.end.js} + '9': {name: string.unquoted.js} + '10': {name: entity.name.function.js} + '11': {name: punctuation.separator.key-value.js} + '12': {name: storage.type.js} + '13': {name: storage.type.function.js} + '14': {name: keyword.generator.asterisk.js} + '15': {name: entity.name.function.js} + end: (?<=\)) + patterns: + - include: '#flowtype-polymorph' + - include: '#function-declaration-parameters' + + literal-arrow-function: + patterns: + # e.g. (args) => { } + # e.g. play = (args) => { } + - name: meta.function.arrow.js + begin: >- + (?x) + (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? + (?:\b(async)\s+)? + (?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) + beginCaptures: + '1': {name: entity.name.function.js} + '2': {name: keyword.operator.assignment.js} + '3': {name: storage.type.js} + end: (?<=\))\s*(=>) + endCaptures: + '1': {name: storage.type.function.arrow.js} + patterns: + - include: '#function-declaration-parameters' + + # e.g. arg => { } + # e.g. play = arg => { } + - name: meta.function.arrow.js + match: >- + (?x) + (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? + (?:(async)\s+)? + \b([_$a-zA-Z][$\w]*)\s*(=>) + captures: + '1': {name: entity.name.function.js} + '2': {name: keyword.operator.assignment.js} + '3': {name: storage.type.js} + '4': {name: variable.parameter.function.js} + '5': {name: storage.type.function.arrow.js} + + # e.g. Sound.prototype.play = (args) => { } + - name: meta.prototype.function.arrow.js + begin: >- + (?x) + (\b_?[A-Z][$\w]*)? + (\.)(prototype) + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(async)? + \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) + beginCaptures: + '1': {name: entity.name.class.js} + '2': {name: keyword.operator.accessor.js} + '3': {name: variable.language.prototype.js} + '4': {name: keyword.operator.accessor.js} + '5': {name: entity.name.function.js} + '6': {name: keyword.operator.assignment.js} + '7': {name: storage.type.js} + end: (?<=\))\s*(=>) + endCaptures: + '1': {name: storage.type.function.arrow.js} + patterns: + - include: '#function-declaration-parameters' + + # e.g. Sound.prototype.play = arg => { } + - name: meta.prototype.function.arrow.js + match: >- + (?x) + (\b_?[A-Z][$\w]*)? + (\.)(prototype) + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(async)? + \s*\b([_$a-zA-Z][$\w]*)\s*(=>) + captures: + '1': {name: entity.name.class.js} + '2': {name: keyword.operator.accessor.js} + '3': {name: variable.language.prototype.js} + '4': {name: keyword.operator.accessor.js} + '5': {name: entity.name.function.js} + '6': {name: keyword.operator.assignment.js} + '7': {name: storage.type.js} + '8': {name: variable.parameter.function.js} + '9': {name: storage.type.function.arrow.js} + + # e.g. Sound.play = (args) => { } + - name: meta.function.static.arrow.js + begin: >- + (?x) + (\b_?[A-Z][$\w]*)? + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(async)? + \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) + beginCaptures: + '1': {name: entity.name.class.js} + '2': {name: keyword.operator.accessor.js} + '3': {name: entity.name.function.js} + '4': {name: keyword.operator.assignment.js} + '5': {name: storage.type.js} + end: (?<=\))\s*(=>) + endCaptures: + '1': {name: storage.type.function.arrow.js} + patterns: + - include: '#function-declaration-parameters' + + # e.g. Sound.play = arg => { } + - name: meta.function.static.arrow.js + match: >- + (?x) + (\b_?[A-Z][$\w]*)? + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(async)? + \s*\b([_$a-zA-Z][$\w]*)\s*(=>) + captures: + '1': {name: entity.name.class.js} + '2': {name: keyword.operator.accessor.js} + '3': {name: entity.name.function.js} + '4': {name: keyword.operator.assignment.js} + '5': {name: storage.type.js} + '6': {name: variable.parameter.function.js} + '7': {name: storage.type.function.arrow.js} + + literal-arrow-function-labels: + patterns: + # e.g. play: (args) => { } + # e.g. "play": (args) => { } + - name: meta.function.json.arrow.js + begin: >- + (?x) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + ) + \s*(:) + \s*(?:\b(async)\s+)? + \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) + beginCaptures: + '1': {name: string.quoted.js} + '2': {name: punctuation.definition.string.begin.js} + '3': {name: entity.name.function.js} + '4': {name: punctuation.definition.string.end.js} + '5': {name: string.quoted.js} + '6': {name: punctuation.definition.string.begin.js} + '7': {name: entity.name.function.js} + '8': {name: punctuation.definition.string.end.js} + '9': {name: string.unquoted.js} + '10': {name: entity.name.function.js} + '11': {name: punctuation.separator.key-value.js} + '12': {name: storage.type.js} + end: (?<=\))\s*(=>) + endCaptures: + '1': {name: storage.type.function.arrow.js} + patterns: + - include: '#function-declaration-parameters' + + # e.g. play: arg => { } + # e.g. "play": arg => { } + - name: meta.function.json.arrow.js + match: >- + (?x) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + ) + \s*(:) + \s*(?:\b(async)\s+)? + \s*\b([_$a-zA-Z][$\w]*)\s*(=>) + captures: + '1': {name: string.quoted.js} + '2': {name: punctuation.definition.string.begin.js} + '3': {name: entity.name.function.js} + '4': {name: punctuation.definition.string.end.js} + '5': {name: string.quoted.js} + '6': {name: punctuation.definition.string.begin.js} + '7': {name: entity.name.function.js} + '8': {name: punctuation.definition.string.end.js} + '9': {name: string.unquoted.js} + '10': {name: entity.name.function.js} + '11': {name: punctuation.separator.key-value.js} + '12': {name: storage.type.js} + '13': {name: variable.parameter.function.js} + '14': {name: storage.type.function.arrow.js} + + literal-function-call: + patterns: + - name: meta.function-call.without-arguments.js + match: ([_$a-zA-Z][$\w]*)\s*(\(\s*\)) + captures: + '1': {name: variable.function.js} + '2': {name: meta.group.braces.round.function.arguments.js} + + - name: meta.function-call.with-arguments.js + match: ([_$a-zA-Z][$\w]*)\s*(?=\() + captures: + '1': {name: variable.function.js} + + - name: meta.function-call.tagged-template.js + match: ([_$a-zA-Z][$\w]*)\s*(?=`) + captures: + '1': {name: variable.function.js} + + literal-method-call: + patterns: + - name: meta.function-call.static.without-arguments.js + match: >- + (?x) + (?:(?<=\.)|\b) + ([A-Z][$\w]*)\s*(\.) + ([_$a-zA-Z][$\w]*)\s* + (\(\s*\)) + captures: + '1': {name: variable.other.class.js} + '2': {name: keyword.operator.accessor.js} + '3': {name: variable.function.js} + '4': {name: meta.group.braces.round.function.arguments.js} + + - name: meta.function-call.static.with-arguments.js + match: >- + (?x) + (?:(?<=\.)|\b) + ([A-Z][$\w]*)\s*(\.) + ([_$a-zA-Z][$\w]*)\s* + (?=\() + captures: + '1': {name: variable.other.class.js} + '2': {name: keyword.operator.accessor.js} + '3': {name: variable.function.js} + + - name: meta.function-call.method.without-arguments.js + match: >- + (?x) + (?<=\.) + ([_$a-zA-Z][$\w]*)\s* + (\(\s*\)) + captures: + '1': {name: variable.function.js} + '2': {name: meta.group.braces.round.function.arguments.js} + + - name: meta.function-call.method.with-arguments.js + match: >- + (?x) + (?<=\.) + ([_$a-zA-Z][$\w]*)\s* + (?=\() + captures: + '1': {name: variable.function.js} + + literal-language-variable: + patterns: + - name: variable.language.arguments.js + match: (?const|let|var)\b + + literal-keywords: + patterns: + - include: '#literal-keyword-storage' + + - match: (?await|yield))\b(?:\s*(\*))? + captures: + '1': {name: keyword.control.flow.js} + '2': {name: keyword.generator.asterisk.js} + + - name: keyword.control.flow.js + match: (?if|else)\b + + - name: keyword.control.trycatch.js + match: (?catch|finally|throw|try)\b + + - name: keyword.control.loop.js + match: (?break|continue|do|goto|while|case|default)\b + + - name: keyword.other.reserved.js + match: (?enum|module|public|package|private|interface|protected)\b + + - name: keyword.other.js + match: (?delete|instanceof|in|new|of|typeof|void|with)\b + + - name: keyword.operator.logical.js + match: >- + (?x) + !(?!=)| # logical-not right-to-left right + && | # logical-and left-to-right both + \|\| # logical-or left-to-right both + + - name: keyword.operator.assignment.js + match: >- + (?x) + =(?!=) # assignment right-to-left both + + - name: keyword.operator.assignment.augmented.js + match: >- + (?x) + %= | # assignment right-to-left both + &= | # assignment right-to-left both + \*= | # assignment right-to-left both + \+= | # assignment right-to-left both + -= | # assignment right-to-left both + /= | # assignment right-to-left both + \^= | # assignment right-to-left both + \|= | # assignment right-to-left both + <<= | # assignment right-to-left both + >>= | # assignment right-to-left both + >>>= # assignment right-to-left both + + - name: keyword.operator.bitwise.js + match: >- + (?x) + ~ | # bitwise-not right-to-left right + << | # bitwise-shift left-to-right both + >>> | # bitwise-shift left-to-right both + >> | # bitwise-shift left-to-right both + & | # bitwise-and left-to-right both + \^ | # bitwise-xor left-to-right both + \| # bitwise-or left-to-right both + + - name: keyword.operator.relational.js + match: >- + (?x) + <= | # relational left-to-right both + >= | # relational left-to-right both + < | # relational left-to-right both + > # relational left-to-right both + + - name: keyword.operator.comparison.js + match: >- + (?x) + === | # equality left-to-right both + !== | # equality left-to-right both + == | # equality left-to-right both + != # equality left-to-right both + + - name: keyword.operator.arithmetic.js + match: >- + (?x) + -- | # decrement n/a right-or-left + \+\+ | # increment n/a right-or-left + / | # division left-to-right both + % | # modulus left-to-right both + \* | # multiplication left-to-right both + \+ | # addition left-to-right both + - # subtraction left-to-right both + + - name: keyword.operator.ternary.js + match: '[?:]' + + - name: keyword.operator.spread.js + match: (?- + (?x) + (? + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + )\s*:) + end: ':' + endCaptures: + '0': {name: punctuation.separator.key-value.js} + patterns: + - include: '#literal-string' + + - name: constant.other.object.key.js + match: (?- + (?xi) + (?:\B[-+])? + (?: + \b0b[0-1]*| # binary + \b0o[0-7]*| # octal + \b0x[0-9a-f]*| # hex + ( + \B\.[0-9]+| # e.g. .999 + \b[0-9]+(\.[0-9]*)? # e.g. 999.999, 999. or 999 + )(e[-+]?[0-9]+)? # e.g. e+123, E-123 + ) + + - name: constant.language.infinity.js + match: (?:\B[-+]|\b)(Infinity)\b + + literal-punctuation: + patterns: + - name: punctuation.terminator.statement.js + match: ; + + - name: meta.delimiter.comma.js + match: ',' + + literal-regexp: + patterns: + # ignore ++, -- since they're uncommon, distinguishing them is not possible in sublime text, see: + # http://stackoverflow.com/questions/5519596/when-parsing-javascript-what-determines-the-meaning-of-a-slash + - name: string.regexp.js + begin: >- + (?x) + (?<= + \.|\(|,|{|}|\[|;|<|>|<=|>=|==|!=|===|!==|\+|-|\*|%|\+\+|--|<<|>>|>>>|&|\||\^|!|~|&&|\|\||\?|:|=|\+=|-=|\*=|%=|<<=|>>=|>>>=|&=|\|=|\^=|/|/=| + \Wnew|\Wdelete|\Wvoid|\Wtypeof|\Winstanceof|\Win|\Wdo|\Wreturn|\Wcase|\Wthrow|\Wyield| + ^new|^delete|^void|^typeof|^instanceof|^in|^do|^return|^case|^throw|^yield|^ + )\s* + (/) + (?!/|\*|$) + beginCaptures: + '1': {name: punctuation.definition.string.begin.js} + end: (/)([gimy]*) + endCaptures: + '1': {name: punctuation.definition.string.end.js} + '2': {name: keyword.other.js} + patterns: + - include: source.regexp.js + + literal-string: + patterns: + - name: string.quoted.js + begin: (["']) + beginCaptures: + '0': {name: punctuation.definition.string.begin.js} + end: (\1)|(\n) + endCaptures: + '1': {name: punctuation.definition.string.end.js} + '2': {name: invalid.illegal.newline.js} + patterns: + - include: '#string-content' + + literal-template-string: + begin: '`' + beginCaptures: + '0': {name: string.interpolated.js keyword.other.template.begin.js} + end: '`' + captures: + '0': {name: string.interpolated.js keyword.other.template.end.js} + patterns: + - include: '#string-content' + - name: constant.character.escape.js + match: \\` + - begin: \${ + beginCaptures: + '0': {name: keyword.other.substitution.begin.js} + end: '}' + endCaptures: + '0': {name: keyword.other.substitution.end.js} + patterns: + - include: '#expression' + # Workaround so themes color the contents of template strings as "string", + # but not any interpolated expression within. + - name: string.interpolated.js + match: '.' + + string-content: + # https://mathiasbynens.be/notes/javascript-escapes + patterns: + - name: constant.character.escape.newline.js + match: \\\s*\n + + - name: constant.character.escape.js + match: \\([1-7][0-7]{0,2}|[0-7]{2,3}|[bfnrtv0'"\\]|x\h{2}|u\{\h+\}|u\h{4}) + + # https://github.com/styled-components/styled-components + styled-components: + patterns: + - name: meta.styled-components.js + begin: (?(?>[^()]+)|\g<-1>)*\))\s*`) + captures: + '1': {name: meta.function-call.with-arguments.js variable.function.js} + end: (?<=`) + patterns: + # Like #round-brackets, but with "meta.function-call.with-arguments.js" so + # it can stop before the template starts. + - name: meta.function-call.with-arguments.js meta.group.js + begin: \( + beginCaptures: + '0': {name: punctuation.definition.group.begin.js} + end: \) + endCaptures: + '0': {name: punctuation.definition.group.end.js} + patterns: + - include: '#expression' + - begin: '`' + beginCaptures: + '0': {name: punctuation.definition.string.template.begin.js} + end: '`' + contentName: source.css.embedded.js + endCaptures: + '0': {name: punctuation.definition.string.template.end.js} + patterns: + - include: source.js.css + + graphql: + patterns: + - name: meta.graphql.js + begin: '\s*+gql`' + end: '`' + patterns: + - include: source.graphql + - name: js + begin: '\${' + end: '}' + patterns: + - include: '#core' + + - name: meta.graphql.js + begin: '\s*+`#graphql' + end: '`' + patterns: + - include: source.graphql + - name: js + begin: '\${' + end: '}' + patterns: + - include: '#core' + + + literal-variable: + patterns: + # e.g. CONSTANT + - name: variable.other.constant.js + match: _*?[A-Z][_$\dA-Z]*\b + + # e.g. Class.property + - name: meta.property.class.js + match: \b([A-Z][$\w]*)\s*(\.)([_$a-zA-Z][$\w]*) + captures: + '1': {name: variable.other.class.js} + '2': {name: keyword.operator.accessor.js} + '3': {name: variable.other.property.static.js} + + # e.g. obj.property + - name: variable.other.object.js + match: (?Eval|Range|Reference|Syntax|Type|URI)?Error)\b + + - name: support.class.node.js + match: \b(?>Buffer)\b + + support-other: + patterns: + - name: support.function.builtin.js + match: (?document|window)\b + + - name: support.type.object.node.js + match: (?global|GLOBAL|root|__dirname|__filename)\b + + - match: (?|\Wreturn|^return|\Wdefault|^)(?=\s*<[_$a-zA-Z]) + end: (?<=/>|>) + patterns: + - include: '#jsx-tag-start' + + jsx-tag-start: + patterns: + - begin: (<)([_$a-zA-Z][-$:.\w]*[$\w]*) + beginCaptures: + '1': {name: meta.tag.jsx punctuation.definition.tag.begin.jsx} + '2': {name: meta.tag.jsx entity.name.tag.jsx} + end: ()|(/>) + endCaptures: + '1': {name: meta.tag.jsx punctuation.definition.tag.begin.jsx} + '2': {name: meta.tag.jsx entity.name.tag.jsx} + '3': {name: meta.tag.jsx punctuation.definition.tag.end.jsx} + '4': {name: meta.tag.jsx punctuation.definition.tag.end.jsx} + patterns: + - include: '#jsx-tag-end' + - include: '#jsx-attributes' + + - name: invalid.illegal.tag.incomplete.jsx + match: '<' + + jsx-tag-end: + begin: '>' + beginCaptures: + '0': {name: meta.tag.jsx punctuation.definition.tag.end.jsx} + end: (?=- + (?x) + (@)([_$a-zA-Z][$\w]*)\b + captures: + '1': {name: punctuation.definition.tag.js} + '2': {name: entity.name.tag.js} + + merge-conflits: + patterns: + - match: ^([<]{7})\s(.+)$ + captures: + '1': {name: invalid.illegal.conflict-marker.merge-into.js} + '2': {name: invalid.illegal.string.js} + - match: ^([=|]{7})$ + captures: + '1': {name: invalid.illegal.conflict-marker.separator.js} + - match: ^([>]{7})\s(.+)$ + captures: + '1': {name: invalid.illegal.conflict-marker.other-commit.js} + '2': {name: invalid.illegal.string.js} + + flowtype-polymorph: + # http://flowtype.org/blog/2015/03/12/Bounded-Polymorphism.html + name: meta.flowtype.polymorph.js + begin: '<' + beginCaptures: + '0': {name: punctuation.section.flowtype.begin.js} + end: '>' + endCaptures: + '0': {name: punctuation.section.flowtype.end.js} + patterns: + - include: '#flowtype-tokens' + + flowtype-annotation: + patterns: + - name: meta.flowtype.annotation.js + begin: (?:(\?)\s*)?(:) + beginCaptures: + '1': {name: keyword.operator.flowtype.optional.js} + '2': {name: keyword.operator.flowtype.annotation.js} + end: (?=\S) + applyEndPatternLast: 1 + patterns: + - include: '#flowtype-tokens' + + flowtype-brackets: + patterns: + - begin: '{' + beginCaptures: + '0': {name: punctuation.section.flowtype.begin.js} + end: '}' + endCaptures: + '0': {name: punctuation.section.flowtype.end.js} + patterns: + - include: '#flowtype-tokens' + + flowtype-identifier: + patterns: + - include: '#support-class' + + - name: constant.other.primitve.flowtype.js + match: \b(?:any|bool|boolean|mixed|number|string|void)\b + + - name: variable.other.flowtype.js + match: '[_$a-zA-Z][$\w]*' + + - name: keyword.operator.flowtype.optional.js + match: \? + + flowtype-tokens: + patterns: + - begin: (?<=[:?|&=])(?=\s*{) + end: (?<=}) + patterns: + - include: '#flowtype-brackets' + + - name: meta.flowtype.set.js + match: \s*([|&])\s* + captures: + '1': {name: keyword.operator.flowtype.other.js} + + - name: keyword.operator.flowtype.other.js + match: '[*:?&|.]|\.\.\.|\b(typeof)\b' + + - begin: '<' + beginCaptures: + '0': {name: punctuation.section.flowtype.begin.js} + end: '>' + endCaptures: + '0': {name: punctuation.section.flowtype.end.js} + patterns: + - include: '#flowtype-tokens' + + - begin: \[ + beginCaptures: + '0': {name: punctuation.section.flowtype.begin.js} + end: \] + endCaptures: + '0': {name: punctuation.section.flowtype.end.js} + patterns: + - include: '#flowtype-tokens' + + - begin: \( + beginCaptures: + '0': {name: punctuation.section.flowtype.begin.js} + end: \) + endCaptures: + '0': {name: punctuation.section.flowtype.end.js} + patterns: + - include: '#flowtype-tokens' + + - name: meta.flowtype.function.js + begin: '=>' + beginCaptures: + '0': {name: keyword.operator.flowtype.js} + end: (?<=}|[_$a-zA-Z]) + patterns: + - include: '#flowtype-brackets' + - include: '#flowtype-identifier' + - include: '#comments' + + - include: '#flowtype-identifier' + - include: '#literal-string' + - include: '#comments' diff --git a/Packages/JSX/JavaScript (Babel).tmLanguage b/Packages/JSX/JavaScript (Babel).tmLanguage new file mode 100644 index 0000000..d1f580b --- /dev/null +++ b/Packages/JSX/JavaScript (Babel).tmLanguage @@ -0,0 +1,4003 @@ + + + + + fileTypes + + js + jsx + babel + es6 + + firstLineMatch + ^#!\s*/.*\b(node|js)$\n? + name + JavaScript (Babel) + patterns + + + include + #core + + + repository + + brackets + + patterns + + + include + #round-brackets + + + include + #square-brackets + + + include + #curly-brackets + + + + class-method-definition + + patterns + + + begin + (@@[_$a-zA-Z][$\w]*|static|return)(?=\s*[<(])|(?=\s*<) + beginCaptures + + 1 + + name + keyword.operator.flowtype.js + + + end + (?=\s*[;{]) + name + meta.short-method.flowtype.js + patterns + + + include + #flowtype-polymorph + + + include + #function-declaration-parameters + + + include + #flowtype-annotation + + + include + #comments + + + include + #curly-brackets + + + + + begin + (?<=[]"'])\s*(?=[<(]) + end + (?=\s*[;{]) + name + meta.class-method.computed.js + patterns + + + include + #flowtype-polymorph + + + include + #function-declaration-parameters + + + include + #flowtype-annotation + + + include + #comments + + + include + #curly-brackets + + + + + begin + (?x) + ((?>get|set)\s+) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + )(?=\s*[<(]) + beginCaptures + + 1 + + name + storage.type.js + + 10 + + name + string.unquoted.js + + 11 + + name + entity.name.function.js + + 2 + + name + string.quoted.js + + 3 + + name + punctuation.definition.string.begin.js + + 4 + + name + entity.name.function.js + + 5 + + name + punctuation.definition.string.end.js + + 6 + + name + string.quoted.js + + 7 + + name + punctuation.definition.string.begin.js + + 8 + + name + entity.name.function.js + + 9 + + name + punctuation.definition.string.end.js + + + end + (?=\s*[;{]) + name + meta.class-accessor.js + patterns + + + include + #flowtype-polymorph + + + include + #function-declaration-parameters + + + include + #flowtype-annotation + + + include + #comments + + + include + #curly-brackets + + + + + begin + (?x) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + )(?=\s*[<(]) + beginCaptures + + 1 + + name + string.quoted.js + + 10 + + name + entity.name.function.js + + 2 + + name + punctuation.definition.string.begin.js + + 3 + + name + entity.name.function.js + + 4 + + name + punctuation.definition.string.end.js + + 5 + + name + string.quoted.js + + 6 + + name + punctuation.definition.string.begin.js + + 7 + + name + entity.name.function.js + + 8 + + name + punctuation.definition.string.end.js + + 9 + + name + string.unquoted.js + + + end + (?=\s*[;{]) + name + meta.class-method.js + patterns + + + include + #flowtype-polymorph + + + include + #function-declaration-parameters + + + include + #flowtype-annotation + + + include + #comments + + + include + #curly-brackets + + + + + + class-method-storage + + patterns + + + match + (?<!\.)\b(?>static|declare)\b + name + storage.modifier.js + + + match + (?<!\.)\b(async)\b + name + storage.type.js + + + match + (?<!\.)\b(get|set)\b(?!\s*\() + name + storage.type.js + + + match + \* + name + keyword.generator.asterisk.js + + + + class-properties + + patterns + + + begin + ([_$a-zA-Z][$\w]*)(?=\s*[:=]) + beginCaptures + + 1 + + name + variable.other.property.js + + + end + (?=\s*[;}]) + name + meta.class.property.js + patterns + + + include + #flowtype-annotation + + + include + #expression + + + + + + comments + + patterns + + + begin + /\*\*(?!/) + captures + + 0 + + name + punctuation.definition.comment.js + + + end + \*/ + name + comment.block.documentation.js + + + begin + /\* + beginCaptures + + 0 + + name + punctuation.definition.comment.begin.js + + + end + \*/ + endCaptures + + 0 + + name + punctuation.definition.comment.end.js + + + name + comment.block.js + + + captures + + 0 + + name + punctuation.definition.comment.js + + + match + (?><!--|-->) + name + comment.block.html.js + + + captures + + 1 + + name + punctuation.definition.comment.js + + + match + (//).*$\n? + name + comment.line.double-slash.js + + + captures + + 1 + + name + punctuation.definition.comment.js + + + match + ^(#!).*$\n? + name + comment.line.shebang.js + + + + core + + patterns + + + include + #literal-function-labels + + + include + #literal-arrow-function-labels + + + include + #literal-labels + + + include + #literal-for + + + include + #literal-switch + + + include + #styled-components + + + include + #graphql + + + include + #expression + + + include + #literal-punctuation + + + + curly-brackets + + patterns + + + begin + { + beginCaptures + + 0 + + name + meta.brace.curly.begin.js + + + end + } + endCaptures + + 0 + + name + meta.brace.curly.end.js + + + name + meta.group.braces.curly.js + patterns + + + include + $self + + + + + + es7-decorators + + patterns + + + captures + + 1 + + name + punctuation.definition.tag.js + + 2 + + name + entity.name.tag.js + + + match + (?x) + (@)([_$a-zA-Z][$\w]*)\b + name + tag.decorator.js + + + + expression + + patterns + + + include + #merge-conflits + + + include + #literal-regexp + + + include + #literal-jsx + + + include + #es7-decorators + + + include + #support-class + + + include + #support-other + + + include + #literal-function + + + include + #literal-arrow-function + + + include + #literal-prototype + + + include + #literal-keywords + + + include + #literal-method + + + include + #literal-module + + + include + #literal-class + + + include + #flowtype-declaration + + + include + #literal-number + + + include + #literal-template-string + + + include + #literal-string + + + include + #literal-language-constant + + + include + #literal-language-variable + + + include + #literal-constructor + + + include + #literal-method-call + + + include + #literal-function-call + + + include + #comments + + + include + #brackets + + + include + #literal-operators + + + include + #literal-variable + + + + flowtype-annotation + + patterns + + + applyEndPatternLast + 1 + begin + (?:(\?)\s*)?(:) + beginCaptures + + 1 + + name + keyword.operator.flowtype.optional.js + + 2 + + name + keyword.operator.flowtype.annotation.js + + + end + (?=\S) + name + meta.flowtype.annotation.js + patterns + + + include + #flowtype-tokens + + + + + + flowtype-brackets + + patterns + + + begin + { + beginCaptures + + 0 + + name + punctuation.section.flowtype.begin.js + + + end + } + endCaptures + + 0 + + name + punctuation.section.flowtype.end.js + + + patterns + + + include + #flowtype-tokens + + + + + + flowtype-declaration + + patterns + + + match + (?<!\.)\b(declare)\b + name + support.type.declare.flowtype.js + + + begin + (?<!\.)\b(type)\b(?=\s*[_$a-zA-Z]) + beginCaptures + + 1 + + name + support.type.type.flowtype.js + + + end + (?=\s*(;|from)) + name + meta.type.flowtype.js + patterns + + + include + #flowtype-tokens + + + + + begin + (?<!\.)\b(type)\b(?=\s*{) + beginCaptures + + 1 + + name + support.type.type.flowtype.js + + + end + (?<=}) + name + meta.type.flowtype.js + patterns + + + include + #comments + + + include + #flowtype-brackets + + + include + #flowtype-polymorph + + + match + ([_$a-zA-Z][$\w]*) + name + entity.name.type.js + + + + + + flowtype-identifier + + patterns + + + include + #support-class + + + match + \b(?:any|bool|boolean|mixed|number|string|void)\b + name + constant.other.primitve.flowtype.js + + + match + [_$a-zA-Z][$\w]* + name + variable.other.flowtype.js + + + match + \? + name + keyword.operator.flowtype.optional.js + + + + flowtype-polymorph + + begin + < + beginCaptures + + 0 + + name + punctuation.section.flowtype.begin.js + + + end + > + endCaptures + + 0 + + name + punctuation.section.flowtype.end.js + + + name + meta.flowtype.polymorph.js + patterns + + + include + #flowtype-tokens + + + + flowtype-tokens + + patterns + + + begin + (?<=[:?|&=])(?=\s*{) + end + (?<=}) + patterns + + + include + #flowtype-brackets + + + + + captures + + 1 + + name + keyword.operator.flowtype.other.js + + + match + \s*([|&])\s* + name + meta.flowtype.set.js + + + match + [*:?&|.]|\.\.\.|\b(typeof)\b + name + keyword.operator.flowtype.other.js + + + begin + < + beginCaptures + + 0 + + name + punctuation.section.flowtype.begin.js + + + end + > + endCaptures + + 0 + + name + punctuation.section.flowtype.end.js + + + patterns + + + include + #flowtype-tokens + + + + + begin + \[ + beginCaptures + + 0 + + name + punctuation.section.flowtype.begin.js + + + end + \] + endCaptures + + 0 + + name + punctuation.section.flowtype.end.js + + + patterns + + + include + #flowtype-tokens + + + + + begin + \( + beginCaptures + + 0 + + name + punctuation.section.flowtype.begin.js + + + end + \) + endCaptures + + 0 + + name + punctuation.section.flowtype.end.js + + + patterns + + + include + #flowtype-tokens + + + + + begin + => + beginCaptures + + 0 + + name + keyword.operator.flowtype.js + + + end + (?<=}|[_$a-zA-Z]) + name + meta.flowtype.function.js + patterns + + + include + #flowtype-brackets + + + include + #flowtype-identifier + + + include + #comments + + + + + include + #flowtype-identifier + + + include + #literal-string + + + include + #comments + + + + function-declaration-parameters + + patterns + + + begin + \( + beginCaptures + + 0 + + name + punctuation.definition.parameters.begin.js + + + end + \) + endCaptures + + 0 + + name + punctuation.definition.parameters.end.js + + + patterns + + + include + #comments + + + include + #flowtype-annotation + + + match + (?<!\.)\.\.\. + name + keyword.operator.spread.js + + + match + ([_$a-zA-Z][$\w]*) + name + variable.parameter.function.js + + + match + , + name + punctuation.separator.parameter.function.js + + + begin + = + beginCaptures + + 0 + + name + keyword.operator.assignment.js + + + end + (?=[,)]) + name + meta.parameter.optional.js + patterns + + + include + #expression + + + + + + + + graphql + + patterns + + + begin + \s*+gql` + end + ` + name + meta.graphql.js + patterns + + + include + source.graphql + + + begin + \${ + end + } + name + js + patterns + + + include + #core + + + + + + + begin + \s*+`#graphql + end + ` + name + meta.graphql.js + patterns + + + include + source.graphql + + + begin + \${ + end + } + name + js + patterns + + + include + #core + + + + + + + + jsx-attribute-assignment + + match + = + name + keyword.operator.assignment.jsx + + jsx-attribute-name + + match + [_$a-zA-Z][-$\w]* + name + entity.other.attribute-name.jsx + + jsx-attributes + + patterns + + + include + #jsx-attribute-name + + + include + #jsx-attribute-assignment + + + include + #jsx-string-quoted + + + include + #jsx-evaluated-code + + + include + #comments + + + + jsx-entities + + patterns + + + match + &(?:[a-zA-Z0-9]+|#\d+|#x\h+); + name + constant.character.entity.jsx + + + match + &\S*; + name + invalid.illegal.bad-ampersand.jsx + + + + jsx-evaluated-code + + begin + { + beginCaptures + + 0 + + name + punctuation.section.embedded.begin.jsx + + + end + } + endCaptures + + 0 + + name + punctuation.section.embedded.end.jsx + + + name + meta.embedded.expression.jsx + patterns + + + include + #expression + + + + jsx-string-quoted + + begin + (["']) + beginCaptures + + 0 + + name + punctuation.definition.string.begin.jsx + + + end + \1 + endCaptures + + 0 + + name + punctuation.definition.string.end.jsx + + + name + string.quoted.jsx + patterns + + + include + #jsx-entities + + + + jsx-tag-end + + begin + > + beginCaptures + + 0 + + name + meta.tag.jsx punctuation.definition.tag.end.jsx + + + end + (?=</) + patterns + + + include + #jsx-tag-start + + + include + #jsx-evaluated-code + + + include + #jsx-entities + + + + jsx-tag-start + + patterns + + + begin + (<)([_$a-zA-Z][-$:.\w]*[$\w]*) + beginCaptures + + 1 + + name + meta.tag.jsx punctuation.definition.tag.begin.jsx + + 2 + + name + meta.tag.jsx entity.name.tag.jsx + + + end + (</)(\2)(>)|(/>) + endCaptures + + 1 + + name + meta.tag.jsx punctuation.definition.tag.begin.jsx + + 2 + + name + meta.tag.jsx entity.name.tag.jsx + + 3 + + name + meta.tag.jsx punctuation.definition.tag.end.jsx + + 4 + + name + meta.tag.jsx punctuation.definition.tag.end.jsx + + + patterns + + + include + #jsx-tag-end + + + include + #jsx-attributes + + + + + match + < + name + invalid.illegal.tag.incomplete.jsx + + + + literal-arrow-function + + patterns + + + begin + (?x) + (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? + (?:\b(async)\s+)? + (?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) + beginCaptures + + 1 + + name + entity.name.function.js + + 2 + + name + keyword.operator.assignment.js + + 3 + + name + storage.type.js + + + end + (?<=\))\s*(=>) + endCaptures + + 1 + + name + storage.type.function.arrow.js + + + name + meta.function.arrow.js + patterns + + + include + #function-declaration-parameters + + + + + captures + + 1 + + name + entity.name.function.js + + 2 + + name + keyword.operator.assignment.js + + 3 + + name + storage.type.js + + 4 + + name + variable.parameter.function.js + + 5 + + name + storage.type.function.arrow.js + + + match + (?x) + (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? + (?:(async)\s+)? + \b([_$a-zA-Z][$\w]*)\s*(=>) + name + meta.function.arrow.js + + + begin + (?x) + (\b_?[A-Z][$\w]*)? + (\.)(prototype) + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(async)? + \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) + beginCaptures + + 1 + + name + entity.name.class.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + variable.language.prototype.js + + 4 + + name + keyword.operator.accessor.js + + 5 + + name + entity.name.function.js + + 6 + + name + keyword.operator.assignment.js + + 7 + + name + storage.type.js + + + end + (?<=\))\s*(=>) + endCaptures + + 1 + + name + storage.type.function.arrow.js + + + name + meta.prototype.function.arrow.js + patterns + + + include + #function-declaration-parameters + + + + + captures + + 1 + + name + entity.name.class.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + variable.language.prototype.js + + 4 + + name + keyword.operator.accessor.js + + 5 + + name + entity.name.function.js + + 6 + + name + keyword.operator.assignment.js + + 7 + + name + storage.type.js + + 8 + + name + variable.parameter.function.js + + 9 + + name + storage.type.function.arrow.js + + + match + (?x) + (\b_?[A-Z][$\w]*)? + (\.)(prototype) + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(async)? + \s*\b([_$a-zA-Z][$\w]*)\s*(=>) + name + meta.prototype.function.arrow.js + + + begin + (?x) + (\b_?[A-Z][$\w]*)? + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(async)? + \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) + beginCaptures + + 1 + + name + entity.name.class.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + entity.name.function.js + + 4 + + name + keyword.operator.assignment.js + + 5 + + name + storage.type.js + + + end + (?<=\))\s*(=>) + endCaptures + + 1 + + name + storage.type.function.arrow.js + + + name + meta.function.static.arrow.js + patterns + + + include + #function-declaration-parameters + + + + + captures + + 1 + + name + entity.name.class.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + entity.name.function.js + + 4 + + name + keyword.operator.assignment.js + + 5 + + name + storage.type.js + + 6 + + name + variable.parameter.function.js + + 7 + + name + storage.type.function.arrow.js + + + match + (?x) + (\b_?[A-Z][$\w]*)? + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(async)? + \s*\b([_$a-zA-Z][$\w]*)\s*(=>) + name + meta.function.static.arrow.js + + + + literal-arrow-function-labels + + patterns + + + begin + (?x) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + ) + \s*(:) + \s*(?:\b(async)\s+)? + \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) + beginCaptures + + 1 + + name + string.quoted.js + + 10 + + name + entity.name.function.js + + 11 + + name + punctuation.separator.key-value.js + + 12 + + name + storage.type.js + + 2 + + name + punctuation.definition.string.begin.js + + 3 + + name + entity.name.function.js + + 4 + + name + punctuation.definition.string.end.js + + 5 + + name + string.quoted.js + + 6 + + name + punctuation.definition.string.begin.js + + 7 + + name + entity.name.function.js + + 8 + + name + punctuation.definition.string.end.js + + 9 + + name + string.unquoted.js + + + end + (?<=\))\s*(=>) + endCaptures + + 1 + + name + storage.type.function.arrow.js + + + name + meta.function.json.arrow.js + patterns + + + include + #function-declaration-parameters + + + + + captures + + 1 + + name + string.quoted.js + + 10 + + name + entity.name.function.js + + 11 + + name + punctuation.separator.key-value.js + + 12 + + name + storage.type.js + + 13 + + name + variable.parameter.function.js + + 14 + + name + storage.type.function.arrow.js + + 2 + + name + punctuation.definition.string.begin.js + + 3 + + name + entity.name.function.js + + 4 + + name + punctuation.definition.string.end.js + + 5 + + name + string.quoted.js + + 6 + + name + punctuation.definition.string.begin.js + + 7 + + name + entity.name.function.js + + 8 + + name + punctuation.definition.string.end.js + + 9 + + name + string.unquoted.js + + + match + (?x) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + ) + \s*(:) + \s*(?:\b(async)\s+)? + \s*\b([_$a-zA-Z][$\w]*)\s*(=>) + name + meta.function.json.arrow.js + + + + literal-class + + patterns + + + begin + (?<!\.)\b(?:(class)|(interface))\b + beginCaptures + + 1 + + name + storage.type.class.js + + 2 + + name + storage.type.interface.flowtype.js + + + end + \} + endCaptures + + 0 + + name + meta.brace.curly.end.js + + + name + meta.class.js + patterns + + + include + #comments + + + begin + ([_$a-zA-Z][$\w]*) + beginCaptures + + 0 + + name + entity.name.class.js + + + end + (?={) + patterns + + + include + #comments + + + include + #flowtype-polymorph + + + begin + (?<!\.)\b(extends)\b + beginCaptures + + 0 + + name + storage.type.extends.js + + + end + (?={) + name + meta.class.extends.js + patterns + + + include + #flowtype-polymorph + + + include + #expression + + + + + + + begin + \{ + beginCaptures + + 0 + + name + meta.brace.curly.begin.js + + + end + (?=}) + patterns + + + include + #es7-decorators + + + include + #class-properties + + + include + #class-method-definition + + + include + #class-method-storage + + + include + #brackets + + + include + #comments + + + + + + + + literal-constructor + + patterns + + + begin + (new)\s+(?=[_$a-zA-Z][$\w.]*) + beginCaptures + + 1 + + name + keyword.operator.new.js + + + end + (?![_$a-zA-Z][$\w.]*) + name + meta.instance.constructor.js + patterns + + + include + #support-class + + + include + #support-other + + + captures + + 2 + + name + variable.function.constructor.js + + + match + ([_$a-zA-Z][$\w.]*\.)?([_$a-zA-Z][$\w]*) + + + + + + literal-for + + patterns + + + begin + (?<!\.)\b(for)\b + beginCaptures + + 1 + + name + keyword.control.loop.js + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.end.js + + + name + meta.for.js + patterns + + + include + #comments + + + begin + \( + beginCaptures + + 0 + + name + meta.brace.round.begin.js + + + end + (?=\)) + patterns + + + include + #literal-keyword-storage + + + include + #expression + + + include + #literal-punctuation + + + + + + + + literal-function + + patterns + + + begin + (?x) + (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? + (?:(async)\s+)? + (function)(?>\s*(\*)|(?=[\s(<])) + \s*([_$a-zA-Z][$\w]*)? + beginCaptures + + 1 + + name + entity.name.function.js + + 2 + + name + keyword.operator.assignment.js + + 3 + + name + storage.type.js + + 4 + + name + storage.type.function.js + + 5 + + name + keyword.generator.asterisk.js + + 6 + + name + entity.name.function.js + + + end + (?<=\)) + name + meta.function.js + patterns + + + include + #flowtype-polymorph + + + include + #function-declaration-parameters + + + + + begin + (?x) + (\b_?[A-Z][$\w]*)? + (\.)(prototype) + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(?:(async)\s+)? + \s*(function)(?>\s*(\*)|(?=[\s(<])) + \s*([_$a-zA-Z][$\w]*)?\s* + beginCaptures + + 1 + + name + entity.name.class.js + + 10 + + name + entity.name.function.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + variable.language.prototype.js + + 4 + + name + keyword.operator.accessor.js + + 5 + + name + entity.name.function.js + + 6 + + name + keyword.operator.assignment.js + + 7 + + name + storage.type.js + + 8 + + name + storage.type.function.js + + 9 + + name + keyword.generator.asterisk.js + + + end + (?<=\)) + name + meta.function.prototype.js + patterns + + + include + #flowtype-polymorph + + + include + #function-declaration-parameters + + + + + begin + (?x) + (\b_?[A-Z][$\w]*)? + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(?:(async)\s+)? + \s*(function)(?>\s*(\*)|(?=[\s(<])) + \s*([_$a-zA-Z][$\w]*)?\s* + beginCaptures + + 1 + + name + entity.name.class.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + entity.name.function.js + + 4 + + name + keyword.operator.assignment.js + + 5 + + name + storage.type.js + + 6 + + name + storage.type.function.js + + 7 + + name + keyword.generator.asterisk.js + + 8 + + name + entity.name.function.js + + + end + (?<=\)) + name + meta.function.static.js + patterns + + + include + #flowtype-polymorph + + + include + #function-declaration-parameters + + + + + + literal-function-call + + patterns + + + captures + + 1 + + name + variable.function.js + + 2 + + name + meta.group.braces.round.function.arguments.js + + + match + ([_$a-zA-Z][$\w]*)\s*(\(\s*\)) + name + meta.function-call.without-arguments.js + + + captures + + 1 + + name + variable.function.js + + + match + ([_$a-zA-Z][$\w]*)\s*(?=\() + name + meta.function-call.with-arguments.js + + + captures + + 1 + + name + variable.function.js + + + match + ([_$a-zA-Z][$\w]*)\s*(?=`) + name + meta.function-call.tagged-template.js + + + + literal-function-labels + + patterns + + + begin + (?x) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + ) + \s*(:) + \s*(?:\b(async)\s+)? + \s*(function)(?>\s*(\*)|(?=[\s(<])) + \s*([_$a-zA-Z][$\w]*)? + beginCaptures + + 1 + + name + string.quoted.js + + 10 + + name + entity.name.function.js + + 11 + + name + punctuation.separator.key-value.js + + 12 + + name + storage.type.js + + 13 + + name + storage.type.function.js + + 14 + + name + keyword.generator.asterisk.js + + 15 + + name + entity.name.function.js + + 2 + + name + punctuation.definition.string.begin.js + + 3 + + name + entity.name.function.js + + 4 + + name + punctuation.definition.string.end.js + + 5 + + name + string.quoted.js + + 6 + + name + punctuation.definition.string.begin.js + + 7 + + name + entity.name.function.js + + 8 + + name + punctuation.definition.string.end.js + + 9 + + name + string.unquoted.js + + + end + (?<=\)) + name + meta.function.json.js + patterns + + + include + #flowtype-polymorph + + + include + #function-declaration-parameters + + + + + + literal-jsx + + begin + (?<=\(|\{|\[|,|&&|\|\||\?|:|=|=>|\Wreturn|^return|\Wdefault|^)(?=\s*<[_$a-zA-Z]) + contentName + meta.jsx.js + end + (?<=/>|>) + patterns + + + include + #jsx-tag-start + + + + literal-keyword-storage + + patterns + + + match + (?<!\.)\b(?>const|let|var)\b + name + storage.type.js + + + + literal-keywords + + patterns + + + include + #literal-keyword-storage + + + captures + + 1 + + name + keyword.control.flow.js + + 2 + + name + keyword.generator.asterisk.js + + + match + (?<!\.)\b((?>await|yield))\b(?:\s*(\*))? + + + match + (?<!\.)\b(return)\b + name + keyword.control.flow.js + + + match + (?<!\.)\b(?>if|else)\b + name + keyword.control.conditional.js + + + match + (?<!\.)\b(?>catch|finally|throw|try)\b + name + keyword.control.trycatch.js + + + match + (?<!\.)\b(?>break|continue|do|goto|while|case|default)\b + name + keyword.control.loop.js + + + match + (?<!\.)\b(?>enum|module|public|package|private|interface|protected)\b + name + keyword.other.reserved.js + + + match + (?<!\.)\b(debugger)\b + name + keyword.other.js + + + + literal-labels + + patterns + + + begin + (?x) + (?<!\?)(?<!\?\s)(?=(?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + )\s*:) + end + : + endCaptures + + 0 + + name + punctuation.separator.key-value.js + + + patterns + + + include + #literal-string + + + + + captures + + 1 + + name + string.unquoted.label.js + + 2 + + name + punctuation.separator.key-value.js + + + match + (?<!\.|\?|\?\s)([_$a-zA-Z][$\w]*)\s*(:) + name + constant.other.object.key.js + + + + literal-language-constant + + patterns + + + match + (?<!\.)\b(true)\b + name + constant.language.boolean.true.js + + + match + (?<!\.)\b(false)\b + name + constant.language.boolean.false.js + + + match + (?<!\.)\b(null)\b + name + constant.language.null.js + + + match + (?<!\.)\b(undefined)\b + name + constant.language.undefined.js + + + match + (?<!\.)\b(NaN)\b + name + constant.language.nan.js + + + + literal-language-variable + + patterns + + + match + (?<!(?<!\.\.)\.)\b(arguments)\b + name + variable.language.arguments.js + + + match + (?<!(?<!\.\.)\.)\b(super)\b + name + variable.language.super.js + + + match + (?<!(?<!\.\.)\.)\b(this)\b + name + variable.language.this.js + + + match + (?<!(?<!\.\.)\.)\b(self)\b + name + variable.language.self.js + + + match + (?<=\.)(__proto__)\b + name + variable.language.proto.js + + + match + (?<=\.)(constructor)\b + name + variable.language.constructor.js + + + match + (?<=\.)(prototype)\b + name + variable.language.prototype.js + + + + literal-method + + patterns + + + begin + (?x) + (?:\b(static)\s+)? + (?:\b(async)\s+)? + (?:(\*)\s*)? + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + ) + (?=\s*(\((?>(?>[^()]+)|\g<-1>)*\))(?>\s|/\*.*\*/)*\{) + beginCaptures + + 1 + + name + storage.type.js + + 10 + + name + entity.name.function.js + + 11 + + name + punctuation.definition.string.end.js + + 12 + + name + string.unquoted.js + + 13 + + name + entity.name.function.js + + 2 + + name + storage.type.js + + 3 + + name + keyword.generator.asterisk.js + + 4 + + name + string.quoted.js + + 5 + + name + punctuation.definition.string.begin.js + + 6 + + name + entity.name.function.js + + 7 + + name + punctuation.definition.string.end.js + + 8 + + name + string.quoted.js + + 9 + + name + punctuation.definition.string.begin.js + + + end + (?<=\)) + name + meta.method.js + patterns + + + include + #function-declaration-parameters + + + + + begin + (?x) + \b(?:(static)\s+)? + (get|set)\s+ + ([_$a-zA-Z][$\w]*|\d+)\s* + (?=(\((?>(?>[^()]+)|\g<-1>)*\))(?>\s|/\*.*\*/)*\{) + beginCaptures + + 1 + + name + storage.type.js + + 2 + + name + storage.type.accessor.js + + 3 + + name + entity.name.accessor.js + + + end + (?<=\)) + name + meta.accessor.js + patterns + + + include + #function-declaration-parameters + + + + + + literal-method-call + + patterns + + + captures + + 1 + + name + variable.other.class.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + variable.function.js + + 4 + + name + meta.group.braces.round.function.arguments.js + + + match + (?x) + (?:(?<=\.)|\b) + ([A-Z][$\w]*)\s*(\.) + ([_$a-zA-Z][$\w]*)\s* + (\(\s*\)) + name + meta.function-call.static.without-arguments.js + + + captures + + 1 + + name + variable.other.class.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + variable.function.js + + + match + (?x) + (?:(?<=\.)|\b) + ([A-Z][$\w]*)\s*(\.) + ([_$a-zA-Z][$\w]*)\s* + (?=\() + name + meta.function-call.static.with-arguments.js + + + captures + + 1 + + name + variable.function.js + + 2 + + name + meta.group.braces.round.function.arguments.js + + + match + (?x) + (?<=\.) + ([_$a-zA-Z][$\w]*)\s* + (\(\s*\)) + name + meta.function-call.method.without-arguments.js + + + captures + + 1 + + name + variable.function.js + + + match + (?x) + (?<=\.) + ([_$a-zA-Z][$\w]*)\s* + (?=\() + name + meta.function-call.method.with-arguments.js + + + + literal-module + + patterns + + + match + (?<!\.)\b(?>import|export|default|from|as)\b + name + keyword.operator.module.js + + + + literal-number + + patterns + + + match + (?i)(?:\B[-+]|\b)0x[0-9a-f]*\.(\B|\b[0-9]+) + name + invalid.illegal.numeric.hex.js + + + match + (?:\B[-+]|\b)0[0-9]+\.(\B|\b[0-9]+) + name + invalid.illegal.numeric.octal.js + + + match + (?xi) + (?:\B[-+])? + (?: + \b0b[0-1]*| # binary + \b0o[0-7]*| # octal + \b0x[0-9a-f]*| # hex + ( + \B\.[0-9]+| # e.g. .999 + \b[0-9]+(\.[0-9]*)? # e.g. 999.999, 999. or 999 + )(e[-+]?[0-9]+)? # e.g. e+123, E-123 + ) + name + constant.numeric.js + + + match + (?:\B[-+]|\b)(Infinity)\b + name + constant.language.infinity.js + + + + literal-operators + + patterns + + + match + (?<!\.)\b(?>delete|instanceof|in|new|of|typeof|void|with)\b + name + keyword.operator.js + + + match + (?x) + !(?!=)| # logical-not right-to-left right + && | # logical-and left-to-right both + \|\| # logical-or left-to-right both + name + keyword.operator.logical.js + + + match + (?x) + =(?!=) # assignment right-to-left both + name + keyword.operator.assignment.js + + + match + (?x) + %= | # assignment right-to-left both + &= | # assignment right-to-left both + \*= | # assignment right-to-left both + \+= | # assignment right-to-left both + -= | # assignment right-to-left both + /= | # assignment right-to-left both + \^= | # assignment right-to-left both + \|= | # assignment right-to-left both + <<= | # assignment right-to-left both + >>= | # assignment right-to-left both + >>>= # assignment right-to-left both + name + keyword.operator.assignment.augmented.js + + + match + (?x) + ~ | # bitwise-not right-to-left right + << | # bitwise-shift left-to-right both + >>> | # bitwise-shift left-to-right both + >> | # bitwise-shift left-to-right both + & | # bitwise-and left-to-right both + \^ | # bitwise-xor left-to-right both + \| # bitwise-or left-to-right both + name + keyword.operator.bitwise.js + + + match + (?x) + <= | # relational left-to-right both + >= | # relational left-to-right both + < | # relational left-to-right both + > # relational left-to-right both + name + keyword.operator.relational.js + + + match + (?x) + === | # equality left-to-right both + !== | # equality left-to-right both + == | # equality left-to-right both + != # equality left-to-right both + name + keyword.operator.comparison.js + + + match + (?x) + -- | # decrement n/a right-or-left + \+\+ | # increment n/a right-or-left + / | # division left-to-right both + % | # modulus left-to-right both + \* | # multiplication left-to-right both + \+ | # addition left-to-right both + - # subtraction left-to-right both + name + keyword.operator.arithmetic.js + + + match + [?:] + name + keyword.operator.ternary.js + + + match + (?<!\.)\.\.\. + name + keyword.operator.spread.js + + + match + \. + name + keyword.operator.accessor.js + + + + literal-prototype + + patterns + + + captures + + 1 + + name + entity.name.class.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + variable.language.prototype.js + + 4 + + name + keyword.operator.assignment.js + + + match + ([_$a-zA-Z][$\w]*)(\.)(prototype)\s*(=)\s* + name + meta.prototype.declaration.js + + + captures + + 1 + + name + entity.name.class.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + variable.language.prototype.js + + + match + ([_$a-zA-Z][$\w]*)(\.)(prototype)\b + name + meta.prototype.access.js + + + + literal-punctuation + + patterns + + + match + ; + name + punctuation.terminator.statement.js + + + match + , + name + meta.delimiter.comma.js + + + + literal-regexp + + patterns + + + begin + (?x) + (?<= + \.|\(|,|{|}|\[|;|<|>|<=|>=|==|!=|===|!==|\+|-|\*|%|\+\+|--|<<|>>|>>>|&|\||\^|!|~|&&|\|\||\?|:|=|\+=|-=|\*=|%=|<<=|>>=|>>>=|&=|\|=|\^=|/|/=| + \Wnew|\Wdelete|\Wvoid|\Wtypeof|\Winstanceof|\Win|\Wdo|\Wreturn|\Wcase|\Wthrow|\Wyield| + ^new|^delete|^void|^typeof|^instanceof|^in|^do|^return|^case|^throw|^yield|^ + )\s* + (/) + (?!/|\*|$) + beginCaptures + + 1 + + name + punctuation.definition.string.begin.js + + + end + (/)([gimy]*) + endCaptures + + 1 + + name + punctuation.definition.string.end.js + + 2 + + name + keyword.other.js + + + name + string.regexp.js + patterns + + + include + source.regexp.js + + + + + + literal-string + + patterns + + + begin + (["']) + beginCaptures + + 0 + + name + punctuation.definition.string.begin.js + + + end + (\1)|(\n) + endCaptures + + 1 + + name + punctuation.definition.string.end.js + + 2 + + name + invalid.illegal.newline.js + + + name + string.quoted.js + patterns + + + include + #string-content + + + + + + literal-switch + + patterns + + + begin + (?<!\.)\b(switch)\b + beginCaptures + + 1 + + name + keyword.control.switch.js + + + end + \} + endCaptures + + 0 + + name + meta.brace.curly.end.js + + + name + meta.switch.js + patterns + + + include + #comments + + + include + #round-brackets + + + begin + \{ + beginCaptures + + 0 + + name + meta.brace.curly.begin.js + + + end + (?=}) + patterns + + + begin + (?<!\.)\b(case|default)\b + beginCaptures + + 1 + + name + keyword.control.switch.js + + + end + (?=:) + patterns + + + include + #expression + + + + + include + $self + + + + + + + + literal-template-string + + begin + ` + beginCaptures + + 0 + + name + string.interpolated.js keyword.other.template.begin.js + + + captures + + 0 + + name + string.interpolated.js keyword.other.template.end.js + + + end + ` + patterns + + + include + #string-content + + + match + \\` + name + constant.character.escape.js + + + begin + \${ + beginCaptures + + 0 + + name + keyword.other.substitution.begin.js + + + end + } + endCaptures + + 0 + + name + keyword.other.substitution.end.js + + + patterns + + + include + #expression + + + + + match + . + name + string.interpolated.js + + + + literal-variable + + patterns + + + match + _*?[A-Z][_$\dA-Z]*\b + name + variable.other.constant.js + + + captures + + 1 + + name + variable.other.class.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + variable.other.property.static.js + + + match + \b([A-Z][$\w]*)\s*(\.)([_$a-zA-Z][$\w]*) + name + meta.property.class.js + + + captures + + 1 + + name + variable.other.object.js + + + match + (?<!\.)([_$a-zA-Z][$\w]*)\s*(?=[\[\.]) + name + variable.other.object.js + + + captures + + 1 + + name + variable.other.property.js + + + match + (?<=\.)\s*([_$a-zA-Z][$\w]*) + name + meta.property.object.js + + + match + [_$a-zA-Z][$\w]* + name + variable.other.readwrite.js + + + + merge-conflits + + patterns + + + captures + + 1 + + name + invalid.illegal.conflict-marker.merge-into.js + + 2 + + name + invalid.illegal.string.js + + + match + ^([<]{7})\s(.+)$ + + + captures + + 1 + + name + invalid.illegal.conflict-marker.separator.js + + + match + ^([=|]{7})$ + + + captures + + 1 + + name + invalid.illegal.conflict-marker.other-commit.js + + 2 + + name + invalid.illegal.string.js + + + match + ^([>]{7})\s(.+)$ + + + + round-brackets + + patterns + + + begin + \( + beginCaptures + + 0 + + name + meta.brace.round.begin.js + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.end.js + + + name + meta.group.braces.round.js + patterns + + + include + #expression + + + + + + square-brackets + + patterns + + + begin + \[ + beginCaptures + + 0 + + name + meta.brace.square.begin.js + + + end + \] + endCaptures + + 0 + + name + meta.brace.square.end.js + + + name + meta.group.braces.square.js + patterns + + + include + #expression + + + + + + string-content + + patterns + + + match + \\\s*\n + name + constant.character.escape.newline.js + + + match + \\([1-7][0-7]{0,2}|[0-7]{2,3}|[bfnrtv0'"\\]|x\h{2}|u\{\h+\}|u\h{4}) + name + constant.character.escape.js + + + + styled-components + + patterns + + + begin + (?<!\.)\b(injectGlobal|keyframes)\s*(`) + beginCaptures + + 1 + + name + variable.function.tagged-template.js + + 2 + + name + punctuation.definition.string.template.begin.js + + + contentName + source.css.embedded.js + end + ` + endCaptures + + 0 + + name + punctuation.definition.string.template.end.js + + + name + meta.styled-components.js + patterns + + + include + source.js.css + + + + + begin + (?<!\.)\b(styled)(\.)([_$a-zA-Z][$\w]*)\s*(`) + beginCaptures + + 1 + + name + variable.other.object.js + + 2 + + name + punctuation.accessor.js + + 3 + + name + variable.function.tagged-template.js + + 4 + + name + punctuation.definition.string.template.begin.js + + + contentName + source.css.embedded.js + end + ` + endCaptures + + 0 + + name + punctuation.definition.string.template.end.js + + + name + meta.styled-components.js + patterns + + + include + source.js.css + + + + + begin + (?<!\.)\b(styled)\s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*`) + captures + + 1 + + name + meta.function-call.with-arguments.js variable.function.js + + + end + (?<=`) + name + meta.styled-components.js + patterns + + + begin + \( + beginCaptures + + 0 + + name + punctuation.definition.group.begin.js + + + end + \) + endCaptures + + 0 + + name + punctuation.definition.group.end.js + + + name + meta.function-call.with-arguments.js meta.group.js + patterns + + + include + #expression + + + + + begin + ` + beginCaptures + + 0 + + name + punctuation.definition.string.template.begin.js + + + contentName + source.css.embedded.js + end + ` + endCaptures + + 0 + + name + punctuation.definition.string.template.end.js + + + patterns + + + include + source.js.css + + + + + + + + support-class + + patterns + + + match + (?<!\.)\b(Array|ArrayBuffer|Boolean|DataView|Date|Float32Array|Float64Array|Function|Infinity|Int16Array|Int32Array|Int8Array|JSON|Map|Math|NaN|Number|Object|Promise|Proxy|Reflect|RegExp|Set|String|Symbol|System|TypeError|Uint16Array|Uint32Array|Uint8Array|Uint8ClampedArray|WeakMap|WeakSet)\b + name + support.class.builtin.js + + + match + (?<!\.)\b((?>Eval|Range|Reference|Syntax|Type|URI)?Error)\b + name + support.class.error.js + + + match + \b(?>Buffer)\b + name + support.class.node.js + + + + support-other + + patterns + + + match + (?<!\.)\b(constructor|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval|hasOwnProperty|isFinite|isNaN|isPrototypeOf|parseFloat|parseInt|propertyIsEnumerable|toLocaleString|toString|unescape|valueOf)\b + name + support.function.builtin.js + + + match + (?<!\.)\b(clearImmediate|clearInterval|clearTimeout|require|setImmediate|setInterval|setTimeout)\b + name + support.function.node.js + + + match + (?<!\.)\b(?>document|window)\b + name + support.type.object.dom.js + + + match + (?<!\.)\b(?>global|GLOBAL|root|__dirname|__filename)\b + name + support.type.object.node.js + + + captures + + 1 + + name + support.type.object.console.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + support.function.console.js + + + match + (?<!\.)\b(console)(?:(\.)(assert|count|dir|error|group|groupCollapsed|groupEnd|info|log|profile|profileEnd|table|time|timeEnd|trace|warn))?\b + + + captures + + 1 + + name + support.type.object.process.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + support.type.object.process.js + + 4 + + name + support.function.process.js + + + match + (?<!\.)\b(process)(?:(\.)(?:(arch|argv|config|env|execArgv|execPath|exitCode|mainModule|pid|platform|stderr|stdin|stdout|title|version|versions)|(abort|chdir|cwd|exit|getgid|getgroups|getuid|hrtime|initgroups|kill|memoryUsage|nextTick|setgid|setgroups|setuid|umask|uptime)))?\b + + + captures + + 1 + + name + support.type.object.module.js + + 2 + + name + keyword.operator.accessor.js + + 3 + + name + support.type.object.module.js + + + match + (?<!\.)\b(exports|module)(?:(\.)(children|exports|filename|id|loaded|parent))?\b + + + begin + {{ + end + }} + name + meta.tag.mustache.js + + + + + scopeName + source.js + + diff --git a/Packages/JSX/LICENSE b/Packages/JSX/LICENSE new file mode 100644 index 0000000..439db9e --- /dev/null +++ b/Packages/JSX/LICENSE @@ -0,0 +1,22 @@ +Copyright (c) 2015 Andres Suarez + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/Packages/JSX/Next.YAML-tmTheme b/Packages/JSX/Next.YAML-tmTheme new file mode 100644 index 0000000..ded69d2 --- /dev/null +++ b/Packages/JSX/Next.YAML-tmTheme @@ -0,0 +1,854 @@ +# [PackageDev] target_format: plist, ext: tmTheme +name: Next +uuid: 35279c3b-adad-473e-b960-fee631f4d9a5 + +settings: +- settings: + activeGuide: '#3333FFFF' + background: '#000000' + bracketsBackground: '#FF00AA66' + bracketsOptions: background + caret: '#FF0099' + foreground: '#E6E6E6' + guide: '#33333388' + gutter: '#6600FF33' + invisibles: '#404040' + lineHighlight: '#FF009933' + multiEditHighlight: '#00FF0022' + searchHighlight: '#FF00AA99' + selection: '#00FFFF44' + stackGuide: '#333333CC' + +- name: bracket.curly + scope: bracket.curly + settings: + background: '#FF44AA' + foreground: '#3399FF' + +- name: bracket.square + scope: bracket.square + settings: + background: '#2266CC' + foreground: '#FF8800' + +- name: bracket.round + scope: bracket.round + settings: + background: '#9922FF' + foreground: '#00FF00' + +- name: bracket.quote + scope: bracket.quote + settings: + background: '#00FF00' + +- name: comment + scope: comment + settings: + fontStyle: italic + foreground: '#646464FF' + +- name: Invalid + scope: invalid + settings: + background: '#FF000022' + +- name: constant + scope: constant + settings: + foreground: '#3387CCFF' + +- name: Keyword + scope: keyword + settings: + foreground: '#E28964' + +- name: constant.numeric + scope: constant.numeric + settings: + foreground: '#FFFF66' + +- name: Storage + scope: storage + settings: + foreground: '#99CF50' + +- name: storage.modifier + scope: storage.modifier + settings: + foreground: '#CF5099' + +- name: storage.self + scope: storage.self + settings: + fontStyle: bold + foreground: '#CC0033' + +- name: storage.type + scope: storage.type + settings: + foreground: '#CF9950' + +- name: Support + scope: support + settings: + foreground: '#8A5C8DFF' + +- name: entity.name.function + scope: entity.name.function + settings: + foreground: '#BB00FF' + +- name: keyword control + scope: keyword.control + settings: + foreground: '#FF00FF' + +- name: keyword.control.declaration + scope: keyword.control.declaration + settings: + foreground: '#8888AA' + +- name: keyword.control.module + scope: keyword.control.module + settings: + background: '#FFFF3333' + foreground: '#FFFF33' + options: underline + +- name: keyword.control.flow + scope: keyword.control.flow + settings: + background: '#110300' + fontStyle: bold + foreground: '#FF6600' + +- name: keyword.control.conditional + scope: keyword.control.conditional + settings: + foreground: '#FF00FF' + +- name: keyword.control.trycatch + scope: keyword.control.trycatch + settings: + foreground: '#FF0033' + +- name: keyword.control.loop + scope: keyword.control.loop + settings: + foreground: '#009999' + +- name: keyword.control.switch + scope: keyword.control.switch + settings: + foreground: '#999999' + +- name: keyword operator + scope: keyword.operator + settings: + foreground: '#FF0080' + +- name: Function arg + scope: meta.function.argument, variable.parameter, meta.parens.c + settings: + foreground: '#77FF11' + +- name: '' + scope: punctuation.section.embedded + settings: + background: '#0D0D0D37' + foreground: '#00D3FFFF' + +- name: keyword.other.unit + scope: keyword.other.unit, keyword.unit.css + settings: + foreground: '#80FF00FF' + +- name: invalid.illegal + scope: invalid.illegal + settings: + background: '#562D56BF' + foreground: '#FD5FF1FF' + +- name: string.quoted source + scope: string.quoted source + settings: + foreground: '#DAEFA3' + +- name: string constant + scope: string constant + settings: + foreground: '#CFED81' + +- name: string.regexp + scope: string.regexp + settings: + foreground: '#6FFF17' + +- name: punctuation.definition.string + scope: punctuation.definition.string + settings: + background: '#15151501' + foreground: '#B4FF82' + +- name: string.regexp.special + scope: "string.regexp constant.character.escape, string.regexp source.ruby.embedded, string.regexp string.regexp.arbitrary-repitition" + settings: + foreground: '#00D505' + +- name: string.regexp punctuation keyword + scope: string.regexp punctuation keyword + settings: + foreground: '#C559FF' + +- name: string variable + scope: string variable + settings: + foreground: '#8A9A95' + +- name: support.function + scope: support.function + settings: + foreground: '#FCF352FF' + +- name: meta.tag + scope: meta.tag + settings: + foreground: '#4F9EFFFF' + +- name: meta.tag entity + scope: meta.tag entity + settings: + foreground: '#157EFF' + +- name: HTML/XML tag attribute value + scope: meta.tag string.quoted.double.html + settings: + foreground: '#E07D2C' + +- name: html5 tag + scope: meta.tag.block.any.html.html5 + settings: + foreground: '#E88BFCFF' + +- name: html5 tag entity + scope: meta.tag.block.any.html.html5 entity + settings: + foreground: '#D730FAFF' + +- name: meta.tag.inline + scope: "source entity.name.tag, source entity.other.attribute-name,meta.tag.inline, meta.tag.inline entity" + settings: + foreground: '#87A7E2FF' + +- name: html js tag + scope: source.js.embedded.html entity.name.tag.script.html + settings: + foreground: '#FF3535' + +- name: html js tag braces + scope: source.js.embedded.html punctuation.definition.tag.html + settings: + foreground: '#FF1E1E' + +- name: html js tag url + scope: source.js.embedded.html string.quoted.double.html + settings: + foreground: '#FF9D9D' + +- name: Attribute + scope: entity.other.attribute-name + settings: + foreground: '#7349BEFF' + +- name: Meta Toc List + scope: meta.toc-list + settings: + background: '#162C1AFF' + foreground: '#BEFEC7FF' + options: underline + +- name: js variable readwrite + scope: meta.initialization, variable.other.readwrite.js + settings: + foreground: '#FF9122' + +- name: js variable dollar + scope: meta.initialization, variable.other.dollar.js + settings: + fontStyle: italic + foreground: '#FF9122' + +- name: js object + scope: variable.other.object.js + settings: + foreground: '#FFEE00' + +- name: js object with parent + scope: meta.property-name.js variable.other.object.js + settings: + foreground: '#FFFF88' + +- name: support.variable.property.js + scope: support.variable.property.js + settings: + foreground: '#3399FF' + +- name: variable.other.dot-access + scope: variable.other.dot-access + settings: + foreground: '#66FFDD' + +- name: variable.other.property.js + scope: variable.other.property.js + settings: + foreground: '#37C1BE' + +- name: punctuation.section.scope.square.js + scope: punctuation.section.scope.square.js + settings: + foreground: '#FF2404' + +- name: punctuation.section.scope.round.js, meta.brace.round + scope: punctuation.section.scope.round.js, meta.brace.round + settings: + foreground: '#1C38FF' + +- name: punctuation.definition.arrow.js + scope: punctuation.definition.arrow.js + settings: + background: '#001133' + fontStyle: bold + foreground: '#AA00FF' + +- name: entity.arrow.function.js + scope: entity.arrow.function.js + settings: + background: '#001133' + fontStyle: bold + foreground: '#AA00FF' + +- name: variable.language + scope: variable.language + settings: + foreground: '#AA0044' + +- name: variable.language.prototype + scope: variable.language.prototype + settings: + foreground: '#FF6600' + +- name: support.class.error.js + scope: support.class.error.js + settings: + foreground: '#FF5522' + +- name: support.class.builtin.js + scope: support.class.builtin.js + settings: + fontStyle: italic + foreground: '#FFEE00' + +- name: support.class.node.js + scope: support.class.node.js + settings: + foreground: '#1224FE' + +- name: entity.name.function.node.js + scope: entity.name.function.node.js + settings: + foreground: '#D84014' + +- name: support.keyword.node.js + scope: support.keyword.node.js + settings: + fontStyle: bold + foreground: '#99EF25' + +- name: variable.import.destructuring.js + scope: variable.import.destructuring.js + settings: + foreground: '#00BBFF' + +- name: other.object.key.js + scope: other.object.key.js + settings: + foreground: '#1C98C1' + +- name: meta.accessor.js punctuation.definition.parameters + scope: meta.accessor.js punctuation.definition.parameters + settings: + foreground: '#005588' + +- name: storage.type.accessor.js + scope: storage.type.accessor.js + settings: + background: '#001122' + fontStyle: bold italic + foreground: '#0066AA' + +- name: entity.name.module.js, variable.import.parameter.js, variable.other.class.js + scope: entity.name.module.js, variable.import.parameter.js, variable.other.class.js + settings: + background: '#220011' + foreground: '#FF0044' + +- name: storage.type.module.js, storage.type.export.js, storage.type.import.js, storage.type.from.js + scope: storage.type.module.js, storage.type.export.js, storage.type.import.js, storage.type.from.js + settings: + background: '#222211' + foreground: '#CCCC44' + +- name: storage.type.class.js, storage.type.extends.js + scope: storage.type.class.js, storage.type.extends.js + settings: + background: '#001122' + foreground: '#0044AA' + +- name: 'meta.function.call.class.static.js ' + scope: 'meta.function.call.class.static.js ' + settings: + foreground: '#880011' + +- name: variable.other.class.static.js + scope: variable.other.class.static.js + settings: + foreground: '#AA0066' + +- name: entity.name.accessor.js + scope: entity.name.accessor.js + settings: + background: '#001122' + fontStyle: bold italic + foreground: '#00FFCC' + +- name: entity.name.method.js + scope: entity.name.method.js + settings: + background: '#110022' + fontStyle: italic bold + foreground: '#AA00FF' + +- name: meta.method.js + scope: meta.method.js + settings: + fontStyle: bold + foreground: '#660099' + +- name: storage.type.function.js + scope: storage.type.function.js + settings: + fontStyle: bold + foreground: '#99CC44' + +- name: string.quoted.single + scope: string.quoted.single + settings: + foreground: '#88FFAAAA' + +- name: variable.other.quasi.js + scope: variable.other.quasi.js + settings: + foreground: '#FF0099' + +- name: string.quasi.js + scope: string.quasi.js + settings: + foreground: '#00FF00' + +- name: punctuation.quasi.element + scope: punctuation.quasi.element + settings: + foreground: '#008800' + +- name: entity.quasi.tag.name.js + scope: entity.quasi.tag.name.js + settings: + foreground: '#FFFF00' + +- name: meta.group.braces.square, punctuation.destructuring + scope: meta.group.braces.square string.quoted.single, punctuation.destructuring + settings: + foreground: '#47E9AC' + +- name: string.quoted.double + scope: string.quoted.double + settings: + foreground: '#11BB11' + +- name: punctuation.section.scope.curly.js + scope: punctuation.section.scope.curly.js + settings: + foreground: '#F9044E' + +- name: meta.delimiter.object.comma.js + scope: meta.delimiter.object.comma.js + settings: + foreground: '#00FFFF' + +- name: meta.group.braces.curly string.quoted.single + scope: meta.group.braces.curly string.quoted.single + settings: + foreground: '#16B853' + +- name: support.function + scope: support.function + settings: + foreground: '#B532FF' + +- name: punctuation.definition.string.begin.js + scope: punctuation.definition.string.begin.js + settings: + foreground: '#D2E20C' + +- name: punctuation.definition.string.end.js + scope: punctuation.definition.string.end.js + settings: + foreground: '#CEA30D' + +- name: instance constructor + scope: meta.class.inheritance, meta.instance.constructor + settings: + fontStyle: italic underline + foreground: '#E81E41' + +- name: entity.name.class.js + scope: entity.name.class.js + settings: + background: '#00FFFF33' + fontStyle: italic + foreground: '#00FFFF' + +- name: entity.name.extends.js + scope: entity.name.extends.js + settings: + background: '#00FF9933' + fontStyle: italic + foreground: '#00FF99' + +- name: function call + scope: meta.function-call entity.name.function + settings: + foreground: '#5B24FF' + +- name: function call with args + scope: meta.function-call.function.with-arguments.js + settings: + foreground: '#33FF00' + +- name: js brace + scope: meta.brace.curly.js + settings: + foreground: '#FF0099' + +- name: js paren + scope: meta.brace.round.js + settings: + background: '#000000FF' + foreground: '#D0C5FEFF' + +- name: js constant escape + scope: constant.character.escape + settings: + foreground: '#10CF62FF' + +- name: pseudo-class + scope: "meta.selector.css entity.other.attribute-name.tag.pseudo-class" + settings: + foreground: '#4FBC4B' + +- name: css selectors + scope: entity.namespace.unicode.css + settings: + foreground: '#FF4F4F' + +- name: entity.other.attribute-name.id + scope: entity.other.attribute-name.id + settings: + background: '#0B0028FF' + foreground: '#F20073FF' + +- name: class name + scope: meta.prototype support.class + settings: + foreground: '#FF0099' + +- name: support object + scope: support.object + settings: + fontStyle: bold + foreground: '#FFEE00' + +- name: class name prototype + scope: meta.prototype support.constant + settings: + foreground: '#FF6600' + +- name: prototype declaration + scope: meta.prototype.declaration.js + settings: + fontStyle: bold + +- name: js undefined + scope: constant.language.undefined.js + settings: + foreground: '#555588' + +- name: variable.other.constant.js + scope: variable.other.constant.js + settings: + background: '#003311' + foreground: '#00FF33' + +- name: 'false' + scope: constant.language.boolean.false + settings: + foreground: '#AAAA55' + +- name: 'true' + scope: constant.language.boolean.true + settings: + foreground: '#CC7744' + +- name: js null + scope: constant.language.null.js + settings: + foreground: '#558855' + +- name: css#id punctuation + scope: punctuation.definition.entity.id.css + settings: + background: '#0B0028' + foreground: '#FF489F' + +- name: css.class + scope: "entity.other.attribute-name.class, source.css.less entity.other.attribute-name.class.css" + settings: + background: '#0B0028' + foreground: '#9529B8' + +- name: css.class puntuation + scope: punctuation.definition.entity.class.css + settings: + background: '#0B0028FF' + foreground: '#CD87E4FF' + +- name: css pseudo element + scope: entity.other.attribute-name.pseudo-element.css + settings: + background: '#0B0028FF' + foreground: '#FF00FFFF' + +- name: css property-name + scope: support.type.property-name.css + settings: + foreground: '#B8EFECFF' + +- name: css @at-rule + scope: meta.preprocessor.at-rule keyword.control.at-rule + settings: + foreground: '#D7C271FF' + +- name: css color + scope: "constant.other.color.rgb-value.css, support.constant.color.w3c-standard-color-name.css" + settings: + foreground: '#FB7720FF' + +- name: css constants + scope: support.constant.property-value.css + settings: + foreground: '#7CE85EFF' + +- name: Puncation Termination + scope: punctuation.terminator, punctuation.separator + settings: + foreground: '#4BFCF8FF' + +- name: css constructor.argument + scope: meta.constructor.argument.css + settings: + foreground: '#8F9D6AFF' + +- name: diff.header + scope: meta.diff, meta.diff.header, entity.name.namespace + settings: + background: '#0E2231FF' + foreground: '#F8F8F8FF' + +- name: diff.deleted + scope: markup.deleted + settings: + background: '#420E09FF' + foreground: '#F8F8F8FF' + +- name: diff.changed + scope: markup.changed + settings: + background: '#4A410DFF' + foreground: '#F8F8F8FF' + +- name: diff.inserted + scope: markup.inserted + settings: + background: '#253B22FF' + foreground: '#F8F8F8FF' + +- name: 'Markup: Italic' + scope: markup.italic + settings: + fontStyle: italic + foreground: '#6AD500FF' + +- name: 'Markup: Underline' + scope: markup.underline + settings: + foreground: '#E18964FF' + options: underline + +- name: 'Markup: Quote' + scope: markup.quote + settings: + background: '#FEE09C12' + fontStyle: italic + foreground: '#E1D4B9FF' + +- name: 'Markup: Heading' + scope: markup.heading, markup.heading entity + settings: + background: '#DE3280FF' + foreground: '#FFFFFFFF' + +- name: 'Markup: List' + scope: markup.list + settings: + foreground: '#6657EAFF' + +- name: 'Markup: Raw' + scope: markup.raw + settings: + background: '#B1B3BA08' + foreground: '#578BB3FF' + +- name: 'Markup: Comment' + scope: markup comment + settings: + foreground: '#F67B37FF' + +- name: 'Markup: Separator' + scope: meta.separator + settings: + background: '#242424FF' + foreground: '#60A633FF' + +- name: Log Entry + scope: meta.line.entry.logfile, meta.line.exit.logfile + settings: + background: '#EEEEEE29' + foreground: '#F8F8F8FF' + +- name: Log Entry Error + scope: meta.line.error.logfile + settings: + background: '#751012' + foreground: '#F8F8F8' + +- name: JSON property top + scope: meta.structure.dictionary.json string.quoted.double + settings: + background: '#111111' + foreground: '#1144BB' + +- name: JSON property level 2 + scope: "meta.structure meta.structure.dictionary.json string.quoted.double" + settings: + foreground: '#1122BB' + +- name: JSON property level 3 + scope: "meta.structure meta.structure meta.structure meta.structure.dictionary.json string.quoted.double" + settings: + foreground: '#2938EB' + +- name: JSON property level 4 + scope: "meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.json string.quoted.double" + settings: + foreground: '#6D7EF1' + +- name: JSON property level 5 + scope: "meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.json string.quoted.double" + settings: + foreground: '#B3BBF7' + +- name: JSON value + scope: meta.structure.dictionary.value.json string.quoted.double + settings: + foreground: '#AA00AA' + +- name: JSON value level 2 + scope: "meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double" + settings: + foreground: '#BF00BF' + +- name: JSON value level 3 + scope: "meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double" + settings: + foreground: '#FF00FF' + +- name: JSON value level 4 + scope: "meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double" + settings: + foreground: '#FF40FF' + +- name: JSON value level 5 + scope: "meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double" + settings: + foreground: '#FF80FF' + +- name: JSON value string punctuation + scope: "meta.structure.dictionary.value.json string punctuation.definition.string.double" + settings: + foreground: '#8409FF' + +- name: JSON array value + scope: meta.structure.array.json string.quoted.double + settings: + foreground: '#5522AA' + +- name: JSON array value level 1 + scope: "meta.structure meta.structure meta.structure.array.json string.quoted.double" + settings: + foreground: '#7017C8FF' + +- name: JSON array value level 2 + scope: "meta.structure meta.structure meta.structure meta.structure meta.structure.array.json string.quoted.double" + settings: + foreground: '#9541E9FF' + +- name: JSON array value level 3 + scope: "meta.structure meta.structure meta.structure meta.structure meta.structure.array.json string.quoted.double" + settings: + foreground: '#BA83F1FF' + +- name: JSON array value level 4 + scope: "meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.array.json string.quoted.double" + settings: + foreground: '#DFC6F9FF' + +- name: JSON prop string punctuation + scope: "meta.structure.dictionary.json string punctuation.definition.string" + settings: + foreground: '#66BBDDFF' + +- name: JSON array string puntuation + scope: "meta.structure.array.json string punctuation.definition.string" + settings: + foreground: '#416BE9FF' + +- name: JSON array brackets + scope: meta.structure.array.json punctuation.definition.array + settings: + foreground: '#FCC401FF' + +- name: JSON object braces + scope: "meta.structure.dictionary.json punctuation.definition.dictionary" + settings: + foreground: '#FEDF76FF' diff --git a/Packages/JSX/Next.tmTheme b/Packages/JSX/Next.tmTheme new file mode 100644 index 0000000..2ffcf82 --- /dev/null +++ b/Packages/JSX/Next.tmTheme @@ -0,0 +1,1868 @@ + + + + name + Next + settings + + + settings + + activeGuide + #3333FFFF + background + #000000 + bracketsBackground + #FF00AA66 + bracketsOptions + background + caret + #FF0099 + foreground + #E6E6E6 + guide + #33333388 + gutter + #6600FF33 + invisibles + #404040 + lineHighlight + #FF009933 + multiEditHighlight + #00FF0022 + searchHighlight + #FF00AA99 + selection + #00FFFF44 + stackGuide + #333333CC + + + + name + bracket.curly + scope + bracket.curly + settings + + background + #FF44AA + foreground + #3399FF + + + + name + bracket.square + scope + bracket.square + settings + + background + #2266CC + foreground + #FF8800 + + + + name + bracket.round + scope + bracket.round + settings + + background + #9922FF + foreground + #00FF00 + + + + name + bracket.quote + scope + bracket.quote + settings + + background + #00FF00 + + + + name + comment + scope + comment + settings + + fontStyle + italic + foreground + #646464FF + + + + name + Invalid + scope + invalid + settings + + background + #FF000022 + + + + name + constant + scope + constant + settings + + foreground + #3387CCFF + + + + name + Keyword + scope + keyword + settings + + foreground + #E28964 + + + + name + constant.numeric + scope + constant.numeric + settings + + foreground + #FFFF66 + + + + name + Storage + scope + storage + settings + + foreground + #99CF50 + + + + name + storage.modifier + scope + storage.modifier + settings + + foreground + #CF5099 + + + + name + storage.self + scope + storage.self + settings + + fontStyle + bold + foreground + #CC0033 + + + + name + storage.type + scope + storage.type + settings + + foreground + #CF9950 + + + + name + Support + scope + support + settings + + foreground + #8A5C8DFF + + + + name + entity.name.function + scope + entity.name.function + settings + + foreground + #BB00FF + + + + name + keyword control + scope + keyword.control + settings + + foreground + #FF00FF + + + + name + keyword.control.declaration + scope + keyword.control.declaration + settings + + foreground + #8888AA + + + + name + keyword.control.module + scope + keyword.control.module + settings + + background + #FFFF3333 + foreground + #FFFF33 + options + underline + + + + name + keyword.control.flow + scope + keyword.control.flow + settings + + background + #110300 + fontStyle + bold + foreground + #FF6600 + + + + name + keyword.control.conditional + scope + keyword.control.conditional + settings + + foreground + #FF00FF + + + + name + keyword.control.trycatch + scope + keyword.control.trycatch + settings + + foreground + #FF0033 + + + + name + keyword.control.loop + scope + keyword.control.loop + settings + + foreground + #009999 + + + + name + keyword.control.switch + scope + keyword.control.switch + settings + + foreground + #999999 + + + + name + keyword operator + scope + keyword.operator + settings + + foreground + #FF0080 + + + + name + Function arg + scope + meta.function.argument, variable.parameter, meta.parens.c + settings + + foreground + #77FF11 + + + + name + + scope + punctuation.section.embedded + settings + + background + #0D0D0D37 + foreground + #00D3FFFF + + + + name + keyword.other.unit + scope + keyword.other.unit, keyword.unit.css + settings + + foreground + #80FF00FF + + + + name + invalid.illegal + scope + invalid.illegal + settings + + background + #562D56BF + foreground + #FD5FF1FF + + + + name + string.quoted source + scope + string.quoted source + settings + + foreground + #DAEFA3 + + + + name + string constant + scope + string constant + settings + + foreground + #CFED81 + + + + name + string.regexp + scope + string.regexp + settings + + foreground + #6FFF17 + + + + name + punctuation.definition.string + scope + punctuation.definition.string + settings + + background + #15151501 + foreground + #B4FF82 + + + + name + string.regexp.special + scope + string.regexp constant.character.escape, string.regexp source.ruby.embedded, string.regexp string.regexp.arbitrary-repitition + settings + + foreground + #00D505 + + + + name + string.regexp punctuation keyword + scope + string.regexp punctuation keyword + settings + + foreground + #C559FF + + + + name + string variable + scope + string variable + settings + + foreground + #8A9A95 + + + + name + support.function + scope + support.function + settings + + foreground + #FCF352FF + + + + name + meta.tag + scope + meta.tag + settings + + foreground + #4F9EFFFF + + + + name + meta.tag entity + scope + meta.tag entity + settings + + foreground + #157EFF + + + + name + HTML/XML tag attribute value + scope + meta.tag string.quoted.double.html + settings + + foreground + #E07D2C + + + + name + html5 tag + scope + meta.tag.block.any.html.html5 + settings + + foreground + #E88BFCFF + + + + name + html5 tag entity + scope + meta.tag.block.any.html.html5 entity + settings + + foreground + #D730FAFF + + + + name + meta.tag.inline + scope + source entity.name.tag, source entity.other.attribute-name,meta.tag.inline, meta.tag.inline entity + settings + + foreground + #87A7E2FF + + + + name + html js tag + scope + source.js.embedded.html entity.name.tag.script.html + settings + + foreground + #FF3535 + + + + name + html js tag braces + scope + source.js.embedded.html punctuation.definition.tag.html + settings + + foreground + #FF1E1E + + + + name + html js tag url + scope + source.js.embedded.html string.quoted.double.html + settings + + foreground + #FF9D9D + + + + name + Attribute + scope + entity.other.attribute-name + settings + + foreground + #7349BEFF + + + + name + Meta Toc List + scope + meta.toc-list + settings + + background + #162C1AFF + foreground + #BEFEC7FF + options + underline + + + + name + js variable readwrite + scope + meta.initialization, variable.other.readwrite.js + settings + + foreground + #FF9122 + + + + name + js variable dollar + scope + meta.initialization, variable.other.dollar.js + settings + + fontStyle + italic + foreground + #FF9122 + + + + name + js object + scope + variable.other.object.js + settings + + foreground + #FFEE00 + + + + name + js object with parent + scope + meta.property-name.js variable.other.object.js + settings + + foreground + #FFFF88 + + + + name + support.variable.property.js + scope + support.variable.property.js + settings + + foreground + #3399FF + + + + name + variable.other.dot-access + scope + variable.other.dot-access + settings + + foreground + #66FFDD + + + + name + variable.other.property.js + scope + variable.other.property.js + settings + + foreground + #37C1BE + + + + name + punctuation.section.scope.square.js + scope + punctuation.section.scope.square.js + settings + + foreground + #FF2404 + + + + name + punctuation.section.scope.round.js, meta.brace.round + scope + punctuation.section.scope.round.js, meta.brace.round + settings + + foreground + #1C38FF + + + + name + punctuation.definition.arrow.js + scope + punctuation.definition.arrow.js + settings + + background + #001133 + fontStyle + bold + foreground + #AA00FF + + + + name + entity.arrow.function.js + scope + entity.arrow.function.js + settings + + background + #001133 + fontStyle + bold + foreground + #AA00FF + + + + name + variable.language + scope + variable.language + settings + + foreground + #AA0044 + + + + name + variable.language.prototype + scope + variable.language.prototype + settings + + foreground + #FF6600 + + + + name + support.class.error.js + scope + support.class.error.js + settings + + foreground + #FF5522 + + + + name + support.class.builtin.js + scope + support.class.builtin.js + settings + + fontStyle + italic + foreground + #FFEE00 + + + + name + support.class.node.js + scope + support.class.node.js + settings + + foreground + #1224FE + + + + name + entity.name.function.node.js + scope + entity.name.function.node.js + settings + + foreground + #D84014 + + + + name + support.keyword.node.js + scope + support.keyword.node.js + settings + + fontStyle + bold + foreground + #99EF25 + + + + name + variable.import.destructuring.js + scope + variable.import.destructuring.js + settings + + foreground + #00BBFF + + + + name + other.object.key.js + scope + other.object.key.js + settings + + foreground + #1C98C1 + + + + name + meta.accessor.js punctuation.definition.parameters + scope + meta.accessor.js punctuation.definition.parameters + settings + + foreground + #005588 + + + + name + storage.type.accessor.js + scope + storage.type.accessor.js + settings + + background + #001122 + fontStyle + bold italic + foreground + #0066AA + + + + name + entity.name.module.js, variable.import.parameter.js, variable.other.class.js + scope + entity.name.module.js, variable.import.parameter.js, variable.other.class.js + settings + + background + #220011 + foreground + #FF0044 + + + + name + storage.type.module.js, storage.type.export.js, storage.type.import.js, storage.type.from.js + scope + storage.type.module.js, storage.type.export.js, storage.type.import.js, storage.type.from.js + settings + + background + #222211 + foreground + #CCCC44 + + + + name + storage.type.class.js, storage.type.extends.js + scope + storage.type.class.js, storage.type.extends.js + settings + + background + #001122 + foreground + #0044AA + + + + name + meta.function.call.class.static.js + scope + meta.function.call.class.static.js + settings + + foreground + #880011 + + + + name + variable.other.class.static.js + scope + variable.other.class.static.js + settings + + foreground + #AA0066 + + + + name + entity.name.accessor.js + scope + entity.name.accessor.js + settings + + background + #001122 + fontStyle + bold italic + foreground + #00FFCC + + + + name + entity.name.method.js + scope + entity.name.method.js + settings + + background + #110022 + fontStyle + italic bold + foreground + #AA00FF + + + + name + meta.method.js + scope + meta.method.js + settings + + fontStyle + bold + foreground + #660099 + + + + name + storage.type.function.js + scope + storage.type.function.js + settings + + fontStyle + bold + foreground + #99CC44 + + + + name + string.quoted.single + scope + string.quoted.single + settings + + foreground + #88FFAAAA + + + + name + variable.other.quasi.js + scope + variable.other.quasi.js + settings + + foreground + #FF0099 + + + + name + string.quasi.js + scope + string.quasi.js + settings + + foreground + #00FF00 + + + + name + punctuation.quasi.element + scope + punctuation.quasi.element + settings + + foreground + #008800 + + + + name + entity.quasi.tag.name.js + scope + entity.quasi.tag.name.js + settings + + foreground + #FFFF00 + + + + name + meta.group.braces.square, punctuation.destructuring + scope + meta.group.braces.square string.quoted.single, punctuation.destructuring + settings + + foreground + #47E9AC + + + + name + string.quoted.double + scope + string.quoted.double + settings + + foreground + #11BB11 + + + + name + punctuation.section.scope.curly.js + scope + punctuation.section.scope.curly.js + settings + + foreground + #F9044E + + + + name + meta.delimiter.object.comma.js + scope + meta.delimiter.object.comma.js + settings + + foreground + #00FFFF + + + + name + meta.group.braces.curly string.quoted.single + scope + meta.group.braces.curly string.quoted.single + settings + + foreground + #16B853 + + + + name + support.function + scope + support.function + settings + + foreground + #B532FF + + + + name + punctuation.definition.string.begin.js + scope + punctuation.definition.string.begin.js + settings + + foreground + #D2E20C + + + + name + punctuation.definition.string.end.js + scope + punctuation.definition.string.end.js + settings + + foreground + #CEA30D + + + + name + instance constructor + scope + meta.class.inheritance, meta.instance.constructor + settings + + fontStyle + italic underline + foreground + #E81E41 + + + + name + entity.name.class.js + scope + entity.name.class.js + settings + + background + #00FFFF33 + fontStyle + italic + foreground + #00FFFF + + + + name + entity.name.extends.js + scope + entity.name.extends.js + settings + + background + #00FF9933 + fontStyle + italic + foreground + #00FF99 + + + + name + function call + scope + meta.function-call entity.name.function + settings + + foreground + #5B24FF + + + + name + function call with args + scope + meta.function-call.function.with-arguments.js + settings + + foreground + #33FF00 + + + + name + js brace + scope + meta.brace.curly.js + settings + + foreground + #FF0099 + + + + name + js paren + scope + meta.brace.round.js + settings + + background + #000000FF + foreground + #D0C5FEFF + + + + name + js constant escape + scope + constant.character.escape + settings + + foreground + #10CF62FF + + + + name + pseudo-class + scope + meta.selector.css entity.other.attribute-name.tag.pseudo-class + settings + + foreground + #4FBC4B + + + + name + css selectors + scope + entity.namespace.unicode.css + settings + + foreground + #FF4F4F + + + + name + entity.other.attribute-name.id + scope + entity.other.attribute-name.id + settings + + background + #0B0028FF + foreground + #F20073FF + + + + name + class name + scope + meta.prototype support.class + settings + + foreground + #FF0099 + + + + name + support object + scope + support.object + settings + + fontStyle + bold + foreground + #FFEE00 + + + + name + class name prototype + scope + meta.prototype support.constant + settings + + foreground + #FF6600 + + + + name + prototype declaration + scope + meta.prototype.declaration.js + settings + + fontStyle + bold + + + + name + js undefined + scope + constant.language.undefined.js + settings + + foreground + #555588 + + + + name + variable.other.constant.js + scope + variable.other.constant.js + settings + + background + #003311 + foreground + #00FF33 + + + + name + false + scope + constant.language.boolean.false + settings + + foreground + #AAAA55 + + + + name + true + scope + constant.language.boolean.true + settings + + foreground + #CC7744 + + + + name + js null + scope + constant.language.null.js + settings + + foreground + #558855 + + + + name + css#id punctuation + scope + punctuation.definition.entity.id.css + settings + + background + #0B0028 + foreground + #FF489F + + + + name + css.class + scope + entity.other.attribute-name.class, source.css.less entity.other.attribute-name.class.css + settings + + background + #0B0028 + foreground + #9529B8 + + + + name + css.class puntuation + scope + punctuation.definition.entity.class.css + settings + + background + #0B0028FF + foreground + #CD87E4FF + + + + name + css pseudo element + scope + entity.other.attribute-name.pseudo-element.css + settings + + background + #0B0028FF + foreground + #FF00FFFF + + + + name + css property-name + scope + support.type.property-name.css + settings + + foreground + #B8EFECFF + + + + name + css @at-rule + scope + meta.preprocessor.at-rule keyword.control.at-rule + settings + + foreground + #D7C271FF + + + + name + css color + scope + constant.other.color.rgb-value.css, support.constant.color.w3c-standard-color-name.css + settings + + foreground + #FB7720FF + + + + name + css constants + scope + support.constant.property-value.css + settings + + foreground + #7CE85EFF + + + + name + Puncation Termination + scope + punctuation.terminator, punctuation.separator + settings + + foreground + #4BFCF8FF + + + + name + css constructor.argument + scope + meta.constructor.argument.css + settings + + foreground + #8F9D6AFF + + + + name + diff.header + scope + meta.diff, meta.diff.header, entity.name.namespace + settings + + background + #0E2231FF + foreground + #F8F8F8FF + + + + name + diff.deleted + scope + markup.deleted + settings + + background + #420E09FF + foreground + #F8F8F8FF + + + + name + diff.changed + scope + markup.changed + settings + + background + #4A410DFF + foreground + #F8F8F8FF + + + + name + diff.inserted + scope + markup.inserted + settings + + background + #253B22FF + foreground + #F8F8F8FF + + + + name + Markup: Italic + scope + markup.italic + settings + + fontStyle + italic + foreground + #6AD500FF + + + + name + Markup: Underline + scope + markup.underline + settings + + foreground + #E18964FF + options + underline + + + + name + Markup: Quote + scope + markup.quote + settings + + background + #FEE09C12 + fontStyle + italic + foreground + #E1D4B9FF + + + + name + Markup: Heading + scope + markup.heading, markup.heading entity + settings + + background + #DE3280FF + foreground + #FFFFFFFF + + + + name + Markup: List + scope + markup.list + settings + + foreground + #6657EAFF + + + + name + Markup: Raw + scope + markup.raw + settings + + background + #B1B3BA08 + foreground + #578BB3FF + + + + name + Markup: Comment + scope + markup comment + settings + + foreground + #F67B37FF + + + + name + Markup: Separator + scope + meta.separator + settings + + background + #242424FF + foreground + #60A633FF + + + + name + Log Entry + scope + meta.line.entry.logfile, meta.line.exit.logfile + settings + + background + #EEEEEE29 + foreground + #F8F8F8FF + + + + name + Log Entry Error + scope + meta.line.error.logfile + settings + + background + #751012 + foreground + #F8F8F8 + + + + name + JSON property top + scope + meta.structure.dictionary.json string.quoted.double + settings + + background + #111111 + foreground + #1144BB + + + + name + JSON property level 2 + scope + meta.structure meta.structure.dictionary.json string.quoted.double + settings + + foreground + #1122BB + + + + name + JSON property level 3 + scope + meta.structure meta.structure meta.structure meta.structure.dictionary.json string.quoted.double + settings + + foreground + #2938EB + + + + name + JSON property level 4 + scope + meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.json string.quoted.double + settings + + foreground + #6D7EF1 + + + + name + JSON property level 5 + scope + meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.json string.quoted.double + settings + + foreground + #B3BBF7 + + + + name + JSON value + scope + meta.structure.dictionary.value.json string.quoted.double + settings + + foreground + #AA00AA + + + + name + JSON value level 2 + scope + meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double + settings + + foreground + #BF00BF + + + + name + JSON value level 3 + scope + meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double + settings + + foreground + #FF00FF + + + + name + JSON value level 4 + scope + meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double + settings + + foreground + #FF40FF + + + + name + JSON value level 5 + scope + meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double + settings + + foreground + #FF80FF + + + + name + JSON value string punctuation + scope + meta.structure.dictionary.value.json string punctuation.definition.string.double + settings + + foreground + #8409FF + + + + name + JSON array value + scope + meta.structure.array.json string.quoted.double + settings + + foreground + #5522AA + + + + name + JSON array value level 1 + scope + meta.structure meta.structure meta.structure.array.json string.quoted.double + settings + + foreground + #7017C8FF + + + + name + JSON array value level 2 + scope + meta.structure meta.structure meta.structure meta.structure meta.structure.array.json string.quoted.double + settings + + foreground + #9541E9FF + + + + name + JSON array value level 3 + scope + meta.structure meta.structure meta.structure meta.structure meta.structure.array.json string.quoted.double + settings + + foreground + #BA83F1FF + + + + name + JSON array value level 4 + scope + meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.array.json string.quoted.double + settings + + foreground + #DFC6F9FF + + + + name + JSON prop string punctuation + scope + meta.structure.dictionary.json string punctuation.definition.string + settings + + foreground + #66BBDDFF + + + + name + JSON array string puntuation + scope + meta.structure.array.json string punctuation.definition.string + settings + + foreground + #416BE9FF + + + + name + JSON array brackets + scope + meta.structure.array.json punctuation.definition.array + settings + + foreground + #FCC401FF + + + + name + JSON object braces + scope + meta.structure.dictionary.json punctuation.definition.dictionary + settings + + foreground + #FEDF76FF + + + + uuid + 35279c3b-adad-473e-b960-fee631f4d9a5 + + diff --git a/Packages/JSX/README.md b/Packages/JSX/README.md new file mode 100644 index 0000000..75b4e96 --- /dev/null +++ b/Packages/JSX/README.md @@ -0,0 +1,67 @@ +# babel-sublime + +> Only supports **Sublime Text 3**. Sublime Text 2 is no longer supported. + +Language definitions for [ES6+ JavaScript](http://kangax.github.io/compat-table/es6/) with [React JSX syntax](http://facebook.github.io/react/docs/jsx-in-depth.html) extensions. + +## Installation + +Find it as [**Babel**](https://packagecontrol.io/packages/Babel) through [Package Control](https://packagecontrol.io/). + +#### Setting as the default syntax + +To set it as the default syntax for a particular extension: + 1. Open a file with that extension, + 2. Select `View` from the menu, + 3. Then `Syntax` `->` `Open all with current extension as...` `->` `Babel` `->` `JavaScript (Babel)`. + 4. Repeat this for each extension (e.g.: `.js` and `.jsx`). + +#### Setting a Color Scheme + +`Babel` comes bundled with `Next` and `Monokai` from [Benvie/JavaScriptNext.tmLanguage](https://github.com/Benvie/JavaScriptNext.tmLanguage). Select one from `Preferences` `->` `Color Scheme` `->` `Babel` + +#### Advanced usage + +It's possible to set `Babel` as the _only_ JavaScript package by disabling the stock one. To do so, add `"ignored_packages": ["JavaScript"]` to your `Preferences.sublime-settings`. The benefits include: + * extension-less node scripts will automatically be recognized as `JavaScript (Babel)`, + * and reduced clutter in the syntax menu. + +**Keep in mind**, the stock snippets will no longer work (you may still use your own), and other third-party packages that depend on the stock package may break (no known ones so far). + +## Screenshots + +![babel-sublime-vs-sublime-react--react-class](https://raw.githubusercontent.com/babel/babel-sublime/45c7d37/screenshots/compare-react-class@2x.png) + +* `babel-sublime` supports modern JavaScript syntax, including [arrow functions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions), [destructuring](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment), [shorthand methods](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions), [template strings](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/template_strings), and more. + +![babel-sublime-vs-sublime-react--jsx-comments-etc](https://raw.githubusercontent.com/babel/babel-sublime/9a6e85f/screenshots/compare-jsx-comments-etc@2x.png) + +* `babel-sublime` correctly matches JSX comments between attributes, namespaced components, and non-alpha characters in tag/attribute names. + +![babel-sublime-vs-sublime-react--jsx-tight](https://raw.githubusercontent.com/babel/babel-sublime/9a6e85f/screenshots/compare-jsx-tight@2x.png) + +* Greater-/less-than comparisons are correctly identified as such and not mistaken for JSX tags. + +## Snippets + +Find them separately at [babel/babel-sublime-snippets](https://github.com/babel/babel-sublime-snippets) or as [**Babel Snippets**](https://packagecontrol.io/packages/Babel%20Snippets) through [Package Control](https://packagecontrol.io/). + +## Suggested Resources + +Sublime Text Color Schemes which are ready for JavaScript's new features and babel-sublime package. + +#### [Oceanic Next Color Scheme](https://github.com/voronianski/oceanic-next-theme) + +[![](https://raw.githubusercontent.com/voronianski/babel-sublime/master/screenshots/oceanic-next.png)](https://github.com/voronianski/oceanic-next-theme) + +#### [Zeus Color Scheme](https://github.com/zaynali53/Zeus-Theme) + +[![zeus-color-scheme](https://raw.githubusercontent.com/zaynali53/Zeus-Theme/master/Zeus-Color-Scheme.PNG)](https://github.com/zaynali53/Zeus-Theme) + +## About + +Under the hood, _babel-sublime_ is based on the excellent [Benvie/JavaScriptNext.tmLanguage](https://github.com/Benvie/JavaScriptNext.tmLanguage) with JSX syntax support built on top. The initial definitions for JSX came from [reactjs/sublime-react](https://github.com/reactjs/sublime-react) via [yungters/sublime](https://github.com/yungsters/sublime.git) - special thanks go to [@jgebhardt](https://github.com/jgebhardt) and [@zpao](https://github.com/zpao). + +## Contributing + +Pull Requests should include your changes to the respective `YAML-tmKittens` file as well as the converted `tmKittens` file. Use [AAAPackageDev](https://github.com/SublimeText/AAAPackageDev) to convert the `YAML-tmKittens` files. diff --git a/Packages/JSX/Styled Components.tmLanguage b/Packages/JSX/Styled Components.tmLanguage new file mode 100644 index 0000000..0c704e1 --- /dev/null +++ b/Packages/JSX/Styled Components.tmLanguage @@ -0,0 +1,542 @@ + + + + + comment + + foldingStartMarker + /\*\*(?!\*)|\{\s*($|/\*(?!.*?\*/.*\S)) + foldingStopMarker + (?<!\*)\*\*/|^\s*\} + keyEquivalent + ^~C + name + Styled Components + patterns + + + include + #comment-block + + + include + #rule-list + + + repository + + color-values + + patterns + + + comment + http://www.w3.org/TR/CSS21/syndata.html#value-def-color + match + \b(aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow)\b + name + support.constant.color.w3c-standard-color-name.css + + + comment + These colours are mostly recognised but will not validate. ref: http://www.w3schools.com/css/css_colornames.asp + match + \b(aliceblue|antiquewhite|aquamarine|azure|beige|bisque|blanchedalmond|blueviolet|brown|burlywood|cadetblue|chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkgrey|darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|darksalmon|darkseagreen|darkslateblue|darkslategray|darkslategrey|darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dimgrey|dodgerblue|firebrick|floralwhite|forestgreen|gainsboro|ghostwhite|gold|goldenrod|greenyellow|grey|honeydew|hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|lightgoldenrodyellow|lightgray|lightgreen|lightgrey|lightpink|lightsalmon|lightseagreen|lightskyblue|lightslategray|lightslategrey|lightsteelblue|lightyellow|limegreen|linen|magenta|mediumaquamarine|mediumblue|mediumorchid|mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|moccasin|navajowhite|oldlace|olivedrab|orangered|orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|powderblue|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|seashell|sienna|skyblue|slateblue|slategray|slategrey|snow|springgreen|steelblue|tan|thistle|tomato|turquoise|violet|wheat|whitesmoke|yellowgreen)\b + name + invalid.deprecated.color.w3c-non-standard-color-name.css + + + begin + (hsla?|rgba?)\s*(\() + beginCaptures + + 1 + + name + support.function.misc.css + + 2 + + name + punctuation.section.function.css + + + end + (\)) + endCaptures + + 1 + + name + punctuation.section.function.css + + + patterns + + + match + (?x)\b + (0*((1?[0-9]{1,2})|(2([0-4][0-9]|5[0-5])))\s*,\s*){2} + (0*((1?[0-9]{1,2})|(2([0-4][0-9]|5[0-5])))\b) + (\s*,\s*((0?\.[0-9]+)|[0-1]))? + + name + constant.other.color.rgb-value.css + + + match + \b([0-9]{1,2}|100)\s*%,\s*([0-9]{1,2}|100)\s*%,\s*([0-9]{1,2}|100)\s*% + name + constant.other.color.rgb-percentage.css + + + include + #numeric-values + + + + + + comment-block + + begin + /\* + captures + + 0 + + name + punctuation.definition.comment.css + + + end + \*/ + name + comment.block.css + + media-query + + begin + (?i)\s*(only|not)?\s*(all|aural|braille|embossed|handheld|print|projection|screen|tty|tv)? + beginCaptures + + 1 + + name + keyword.operator.logic.media.css + + 2 + + name + support.constant.media.css + + + end + \s*(?:(,)|(?=[{;])) + endCaptures + + 1 + + name + punctuation.definition.arbitrary-repitition.css + + + patterns + + + begin + \s*(and)?\s*(\()\s* + beginCaptures + + 1 + + name + keyword.operator.logic.media.css + + + end + \) + patterns + + + begin + (?x) + ( + ((min|max)-)? + ( + ((device-)?(height|width|aspect-ratio))| + (color(-index)?)|monochrome|resolution + ) + )|grid|scan|orientation + \s*(?=[:)]) + beginCaptures + + 0 + + name + support.type.property-name.media.css + + + end + (:)|(?=\)) + endCaptures + + 1 + + name + punctuation.separator.key-value.css + + + + + match + \b(portrait|landscape|progressive|interlace) + name + support.constant.property-value.css + + + captures + + 1 + + name + constant.numeric.css + + 2 + + name + keyword.operator.arithmetic.css + + 3 + + name + constant.numeric.css + + + match + \s*(\d+)(/)(\d+) + + + include + #numeric-values + + + + + + media-query-list + + begin + \s*(?=[^{;]) + end + \s*(?=[{;]) + patterns + + + include + #media-query + + + + numeric-values + + patterns + + + captures + + 1 + + name + punctuation.definition.constant.css + + + match + (#)([0-9a-fA-F]{3}|[0-9a-fA-F]{6})\b + name + constant.other.color.rgb-value.css + + + captures + + 1 + + name + keyword.other.unit.css + + + match + (?x) + (?:-|\+)?(?:(?:[0-9]+(?:\.[0-9]+)?)|(?:\.[0-9]+)) + ((?:px|pt|ch|cm|mm|in|r?em|ex|pc|deg|g?rad|dpi|dpcm|s)\b|%)? + + name + constant.numeric.css + + + + property-values + + patterns + + + match + \b(absolute|all(-scroll)?|always|armenian|auto|avoid|baseline|below|bidi-override|block|bold|bolder|both|bottom|break-all|break-word|capitalize|center|char|circle|cjk-ideographic|col-resize|collapse|crosshair|dashed|decimal-leading-zero|decimal|default|disabled|disc|distribute-all-lines|distribute-letter|distribute-space|distribute|dotted|double|e-resize|ellipsis|fixed|geometricPrecision|georgian|groove|hand|hebrew|help|hidden|hiragana-iroha|hiragana|horizontal|ideograph-alpha|ideograph-numeric|ideograph-parenthesis|ideograph-space|inactive|inherit|inline-block|inline|inset|inside|inter-ideograph|inter-word|italic|justify|katakana-iroha|katakana|keep-all|left|lighter|line-edge|line-through|line|list-item|loose|lower-alpha|lower-greek|lower-latin|lower-roman|lowercase|lr-tb|ltr|medium|middle|move|n-resize|ne-resize|newspaper|no-drop|no-repeat|nw-resize|none|normal|not-allowed|nowrap|oblique|optimize(Legibility|Quality|Speed)|outset|outside|overline|pointer|pre(-(wrap|line))?|progress|relative|repeat-x|repeat-y|repeat|right|ridge|row-resize|rtl|s-resize|scroll|se-resize|separate|small-caps|solid|square|static|strict|sub|super|sw-resize|table-footer-group|table-header-group|tb-rl|text-bottom|text-top|text|thick|thin|top|transparent|underline|upper-alpha|upper-latin|upper-roman|uppercase|vertical(-(ideographic|text))?|visible(Painted|Fill|Stroke)?|w-resize|wait|whitespace|zero|smaller|larger|((xx?-)?(small|large))|painted|fill|stroke)\b + name + support.constant.property-value.css + + + match + (\b(?i:arial|century|comic|courier|garamond|georgia|helvetica|impact|lucida|symbol|system|tahoma|times|trebuchet|utopia|verdana|webdings|sans-serif|serif|monospace)\b) + name + support.constant.font-name.css + + + include + #numeric-values + + + include + #color-values + + + include + #string-double + + + include + #string-single + + + begin + (rect)\s*(\() + beginCaptures + + 1 + + name + support.function.misc.css + + 2 + + name + punctuation.section.function.css + + + end + (\)) + endCaptures + + 1 + + name + punctuation.section.function.css + + + patterns + + + include + #numeric-values + + + + + begin + (format|local|url|attr|counter|counters)\s*(\() + beginCaptures + + 1 + + name + support.function.misc.css + + 2 + + name + punctuation.section.function.css + + + end + (\)) + endCaptures + + 1 + + name + punctuation.section.function.css + + + patterns + + + include + #string-single + + + include + #string-double + + + match + [^'") \t]+ + name + variable.parameter.misc.css + + + + + match + \!\s*important + name + keyword.other.important.css + + + + rule-list + + begin + + beginCaptures + + 0 + + name + punctuation.section.property-list.css + + + end + (?=\s*) + name + meta.property-list.css + patterns + + + include + #comment-block + + + begin + (?<![-a-z])(?=[-a-z]) + end + $|(?![-a-z]) + name + meta.property-name.css + patterns + + + match + \b(azimuth|background-attachment|background-color|background-image|background-position|background-repeat|background|box-shadow|border-radius|border-bottom-color|border-bottom-style|border-bottom-width|border-bottom|border-collapse|border-color|border-left-color|border-left-style|border-left-width|border-left|border-right-color|border-right-style|border-right-width|border-right|border-spacing|border-style|border-top-color|border-top-style|border-top-width|border-top|border-width|border|bottom|caption-side|clear|clip|color|content|counter-increment|counter-reset|cue-after|cue-before|cue|cursor|direction|display|elevation|empty-cells|flex-basis|flex-direction|flex-flow|flex-grow|flex-shrink|flex-wrap|flex|float|font-family|font-size-adjust|font-size|font-stretch|font-style|font-variant|font-weight|font|height|image-rendering|left|letter-spacing|line-height|list-style-image|list-style-position|list-style-type|list-style|margin-bottom|margin-left|margin-right|margin-top|marker-offset|margin|marks|max-height|max-width|min-height|min-width|-moz-border-radius|opacity|orphans|outline-color|outline-style|outline-width|outline|overflow(-[xy])?|padding-bottom|padding-left|padding-right|padding-top|padding|page-break-after|page-break-before|page-break-inside|page|pause-after|pause-before|pause|pitch-range|pitch|play-during|pointer-events|position|quotes|resize|richness|right|size|speak-header|speak-numeral|speak-punctuation|speech-rate|speak|src|stress|table-layout|text-(align|decoration|indent|rendering|shadow|transform)|top|transition|unicode-bidi|vertical-align|visibility|voice-family|volume|white-space|widows|width|word-(spacing|wrap)|zoom|z-index)\b + name + support.type.property-name.css + + + + + begin + (?<!&|:)(:)\s* + beginCaptures + + 1 + + name + punctuation.separator.key-value.css + + + end + \s*(;|(?=\})) + endCaptures + + 1 + + name + punctuation.terminator.rule.css + + + name + meta.property-value.css + patterns + + + include + #property-values + + + + + + string-double + + begin + " + beginCaptures + + 0 + + name + punctuation.definition.string.begin.css + + + end + " + endCaptures + + 0 + + name + punctuation.definition.string.end.css + + + name + string.quoted.double.css + patterns + + + match + \\. + name + constant.character.escape.css + + + + string-single + + begin + ' + beginCaptures + + 0 + + name + punctuation.definition.string.begin.css + + + end + ' + endCaptures + + 0 + + name + punctuation.definition.string.end.css + + + name + string.quoted.single.css + patterns + + + match + \\. + name + constant.character.escape.css + + + + + scopeName + source.js.css + uuid + b64876fa-0739-4b2b-8e5b-e9e8b9f84514 + + diff --git a/Packages/JSX/messages.json b/Packages/JSX/messages.json new file mode 100644 index 0000000..80aa64c --- /dev/null +++ b/Packages/JSX/messages.json @@ -0,0 +1,8 @@ +{ + "3.0.0": "messages/3.0.0.txt", + "4.0.0": "messages/4.0.0.txt", + "5.0.0": "messages/5.0.0.txt", + "7.1.0": "messages/7.1.0.txt", + "7.1.1": "messages/7.1.0.txt", + "8.0.0": "messages/8.0.0.txt" +} diff --git a/Packages/JSX/messages/3.0.0.txt b/Packages/JSX/messages/3.0.0.txt new file mode 100644 index 0000000..ed3a745 --- /dev/null +++ b/Packages/JSX/messages/3.0.0.txt @@ -0,0 +1,4 @@ +babel-sublime (previously 6to5-sublime) +--------------------------------------- + +6to5 is now Babel, so 6to5-sublime is now babel-sublime. diff --git a/Packages/JSX/messages/4.0.0.txt b/Packages/JSX/messages/4.0.0.txt new file mode 100644 index 0000000..ba1483a --- /dev/null +++ b/Packages/JSX/messages/4.0.0.txt @@ -0,0 +1,4 @@ +babel-sublime (previously 6to5-sublime) +--------------------------------------- + +Snippets have been removed. For more info see https://github.com/babel/babel-sublime/blob/master/SNIPPETS.md diff --git a/Packages/JSX/messages/5.0.0.txt b/Packages/JSX/messages/5.0.0.txt new file mode 100644 index 0000000..193d09e --- /dev/null +++ b/Packages/JSX/messages/5.0.0.txt @@ -0,0 +1,11 @@ +babel-sublime +------------- + +babel-sublime no longer relies on the stock JavaScript package for any functionality. This means you can disable the stock package completely and rely solely on babel-sublime. Why would you want to that though? A few reasons: + + * node scripts without an extension that have a shebang will open with "JavaScript (Babel)" instead of the stock package. + - babel-sublime has always supported this, but because the stock package takes precedence over babel-sublime, it never really worked. + * Less clutter in the syntax menu :) + * No stock snippets. No snippets period. Since babel-sublime doesn't ship with any snippets, only your user defined ones will show up. + +See https://github.com/babel/babel-sublime#advanced-usage for more info. diff --git a/Packages/JSX/messages/7.1.0.txt b/Packages/JSX/messages/7.1.0.txt new file mode 100644 index 0000000..0ed6ae2 --- /dev/null +++ b/Packages/JSX/messages/7.1.0.txt @@ -0,0 +1,28 @@ +babel-sublime +------------- + +Big improvements are coming soon to support flow type annotations. You may +already start to notice some of them, like ES7 property initializers getting +properly matched. But it's coming at a cost: + +There are currently two syntax definitions supporting different builds of +Sublime Text 3 (ST2 doesn't work with either). One is the evolution of the +other using Sublime's new "sublime-syntax" format. That new format allows for +more complex matches, thus paving the way for flow support. If you're using +Sublime Text 3 dev then you're already using the new syntax, if you're +using the beta, then you're still using the old syntax. + +Here's the plan: + +1. Once the next Sublime Text 3 beta build comes out (whenever that is), I'll +be removing the old syntax from the package. Since, that means that most +(if not all) users will be able to use the new syntax. If you still need +the old syntax, Don't Panic, you can clone the repo and run it like that. +I'll put up instructions if that's thing someone wants. + +2. "Monokai Phoenix" will also go away. If you're running ST3 dev, and you're +using Monokai Phoenix, you can already switch the stock Monokai and things +will look mostly the same. The new syntax uses more generic scope names that +make it more theme friendly. + +That's all. diff --git a/Packages/JSX/messages/8.0.0.txt b/Packages/JSX/messages/8.0.0.txt new file mode 100644 index 0000000..69d6201 --- /dev/null +++ b/Packages/JSX/messages/8.0.0.txt @@ -0,0 +1,14 @@ +babel-sublime +------------- + +If you're on the Sublime Text 3 dev channel and using the latest Sublime +build, you should now see substantially improved JSX matching: + + 1. A few lingering edge-cases w.r.t. JSXText have been fixed. + + 2. JSX matching won't interfere with Flow annotations. This is a huge step + towards full Flow support. Before, some Flow arrays got matched as JSX + and that made a mess. Now, they won't get matched, and at worst it just + looks plain. + +That's it. diff --git a/Packages/JSX/messages/9.0.0.txt b/Packages/JSX/messages/9.0.0.txt new file mode 100644 index 0000000..cf9f03f --- /dev/null +++ b/Packages/JSX/messages/9.0.0.txt @@ -0,0 +1,8 @@ +babel-sublime +------------- + +* JSX indentation fixes. +* Support for https://github.com/styled-components/styled-components + - See https://github.com/babel/babel-sublime/pull/289 + +More coming up... diff --git a/Packages/JSX/package.json b/Packages/JSX/package.json new file mode 100644 index 0000000..3fca448 --- /dev/null +++ b/Packages/JSX/package.json @@ -0,0 +1,4 @@ +{ + "dependencies": {}, + "private": true +} diff --git a/Packages/JSX/screenshots/compare-jsx-comments-etc@2x.png b/Packages/JSX/screenshots/compare-jsx-comments-etc@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..6246d27264b3bedd3c11f2f5ceb5fbe69d9f9697 GIT binary patch literal 37079 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 literal 0 HcmV?d00001 diff --git a/Packages/JSX/screenshots/compare-jsx-illegal@2x.png b/Packages/JSX/screenshots/compare-jsx-illegal@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..ac8931f199a72e9e1d8f14ab7aed728cf9953cb2 GIT binary patch literal 30862 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 literal 0 HcmV?d00001 diff --git a/Packages/JSX/screenshots/compare-jsx-tight@2x.png b/Packages/JSX/screenshots/compare-jsx-tight@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..9aa4a2e6b60f52660a72f2f18bbaa06c1448bf77 GIT binary patch literal 24980 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ℑ3yc@O1e`_ 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 Y&FLg{f3Be$+rXcZfvJA+1*eGr0Ye*sJpcdz literal 0 HcmV?d00001 diff --git a/Packages/JSX/screenshots/oceanic-next.png b/Packages/JSX/screenshots/oceanic-next.png new file mode 100644 index 0000000000000000000000000000000000000000..4256f528c486cef1e941785af5da17eb863b4b70 GIT binary patch literal 59838 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
$yz`u$*^si9K%&D2TDEm&=~ur& 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 DQvHLB literal 0 HcmV?d00001 diff --git a/Packages/JSX/test/syntax_test_issues_OLD.js b/Packages/JSX/test/syntax_test_issues_OLD.js new file mode 100644 index 0000000..8b3a41a --- /dev/null +++ b/Packages/JSX/test/syntax_test_issues_OLD.js @@ -0,0 +1,275 @@ +// SYNTAX TEST "Packages/babel-sublime/JavaScript (Babel).tmLanguage" + +/** + * https://github.com/babel/babel-sublime/issues/243 + */ + +class Foo extends create('Bar') {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class +//^^^ meta.class storage.type.class +// ^^^ meta.class entity.name.class +// ^^^^^^^^^^^^^^^^^^^^^^ meta.class meta.class.extends +// ^^^^^^^ meta.class meta.class.extends storage.type.extends +// ^^^^^^^^^^^^^ meta.class meta.class.extends meta.method +// ^^^^^^ meta.class meta.class.extends meta.method string.unquoted entity.name.function +// ^ meta.class meta.class.extends meta.method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class.extends meta.method variable.parameter.function +// ^ meta.class meta.class.extends meta.method punctuation.definition.parameters.end +// ^ meta.class meta.brace.curly.begin +// ^ meta.class meta.brace.curly.end + + +/** + * https://github.com/babel/babel-sublime/issues/244 + */ + +var foo = bar ? "+" + baz : qux; +//^ storage.type +//<- source.js +// ^^^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^^^ variable.other.readwrite +// ^ keyword.operator.ternary +// ^^^ string.quoted +// ^ string.quoted punctuation.definition.string.begin +// ^ string.quoted punctuation.definition.string.end +// ^ keyword.operator.arithmetic +// ^^^^^ constant.other.object.key +// ^^^ constant.other.object.key string.unquoted.label +// ^ constant.other.object.key punctuation.separator.key-value +// ^^^ variable.other.readwrite +// ^ punctuation.terminator.statement + +var foo = bar ? "+" + baz + baz2 : qux; +//^ storage.type +//<- source.js +// ^^^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^^^ variable.other.readwrite +// ^ keyword.operator.ternary +// ^^^ string.quoted +// ^ string.quoted punctuation.definition.string.begin +// ^ string.quoted punctuation.definition.string.end +// ^ keyword.operator.arithmetic +// ^^^ variable.other.readwrite +// ^ keyword.operator.arithmetic +// ^^^^^^ constant.other.object.key +// ^^^^ constant.other.object.key string.unquoted.label +// ^ constant.other.object.key punctuation.separator.key-value +// ^^^ variable.other.readwrite +// ^ punctuation.terminator.statement + +var foo = bar ? "+" + (baz) : qux; +//^ storage.type +//<- source.js +// ^^^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^^^ variable.other.readwrite +// ^ keyword.operator.ternary +// ^^^ string.quoted +// ^ string.quoted punctuation.definition.string.begin +// ^ string.quoted punctuation.definition.string.end +// ^ keyword.operator.arithmetic +// ^ meta.group.braces.round meta.brace.round.begin +// ^^^ meta.group.braces.round variable.other.readwrite +// ^ meta.group.braces.round meta.brace.round.end +// ^ punctuation.separator.key-value +// ^^^ variable.other.readwrite +// ^ punctuation.terminator.statement + + +/** + * https://github.com/babel/babel-sublime/issues/249 + */ + +{{{{{{{{{{{{{{ +//^^^^^^^^^^^^ meta.tag.mustache + console.log +//^^^^^^^^^^^^ meta.tag.mustache +}}}}}}}}}}}}}} +//^^^^^^^^^^^^ source.js - meta.tag.mustache + + +/** + * https://github.com/babel/babel-sublime/issues/253 + */ + +for(let a of list) +//^^^^^^^^^^^^^^^^ meta.for +//^ keyword.control.loop +// ^ meta.brace.round.begin +// ^^^ storage.type +// ^ variable.other.readwrite +// ^^ keyword.operator +// ^^^^ variable.other.readwrite +// ^ meta.for meta.brace.round.end + +for(let a of []) +//^^^^^^^^^^^^^^ meta.for +//^ keyword.control.loop +// ^ meta.brace.round.begin +// ^^^ storage.type +// ^ variable.other.readwrite +// ^^ keyword.operator +// ^ meta.group.braces.square meta.brace.square.begin +// ^ meta.group.braces.square meta.brace.square.end +// ^ meta.brace.round.end + +for(let a of (list || [])) +//^^^^^^^^^^^^^^^^^^^^^^^^ meta.for +//^ keyword.control.loop +//<- source.js +// ^ meta.brace.round.begin +// ^^^ storage.type +// ^ variable.other.readwrite +// ^^^ meta.function-call.with-arguments +// ^^ meta.function-call.with-arguments variable.function +// ^^^^^^^^^^^^ meta.group.braces.round +// ^ meta.group.braces.round meta.brace.round.begin +// ^^^^ meta.group.braces.round variable.other.readwrite +// ^^ meta.group.braces.round keyword.operator.logical +// ^ meta.group.braces.round meta.group.braces.square meta.brace.square.begin +// ^ meta.group.braces.round meta.group.braces.square meta.brace.square.end +// ^^ meta.brace.round.end +// ^ meta.group.braces.round meta.brace.round.end + + +/** + * https://github.com/babel/babel-sublime/issues/256 + */ + +return a ? a*a : 0; +//^^^^ keyword.control.flow +//<- source.js +// ^ variable.other.readwrite +// ^ keyword.operator.ternary +// ^ variable.other.readwrite +// ^ keyword.operator.arithmetic +// ^^^ constant.other.object.key +// ^ constant.other.object.key string.unquoted.label +// ^ constant.other.object.key punctuation.separator.key-value +// ^ constant.numeric +// ^ punctuation.terminator.statement + + +/** + * https://github.com/babel/babel-sublime/issues/270 + */ + +class Foo { +//^^^ meta.class storage.type.class +// ^^^ meta.class entity.name.class +// ^ meta.class meta.brace.curly.begin + bar = baz::map( +//^^^ meta.class.property variable.other.property +// ^ meta.class.property keyword.operator.assignment +// ^^^ meta.class.property variable.other.readwrite +// ^ meta.class.property meta.flowtype.annotation keyword.operator.flowtype.annotation +// ^ meta.class.property meta.flowtype.annotation keyword.operator.flowtype.other +// ^^^ meta.class.property meta.flowtype.annotation variable.other.flowtype +// ^ meta.class.property meta.flowtype.annotation punctuation.section.flowtype.begin + thing => 1 +// ^^^^^ meta.class.property meta.flowtype.annotation variable.other.flowtype +// ^^ meta.class.property meta.flowtype.annotation meta.flowtype.function keyword.operator.flowtype + ); + constructor() {} +//^^^^^^^^^^^ meta.class.property meta.flowtype.annotation meta.flowtype.function variable.other.flowtype +// ^ meta.class.property meta.flowtype.annotation punctuation.section.flowtype.begin +// ^ meta.class.property meta.flowtype.annotation punctuation.section.flowtype.end +} +))} /* END ERROR */ + + +/** + * https://github.com/babel/babel-sublime/issues/274 + */ + +void
{[]}
+//^^ keyword.operator +//<- source.js +// ^ keyword.operator.relational +// ^^^ variable.other.readwrite +// ^ keyword.operator.relational +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^^^^^ meta.group.braces.curly meta.group.braces.square meta.jsx +// ^ meta.group.braces.curly meta.group.braces.square meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.jsx meta.tag entity.name.tag +// ^^ meta.group.braces.curly meta.group.braces.square meta.jsx meta.tag punctuation.definition.tag.end +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly meta.brace.curly.end +// ^ keyword.operator.relational +// ^^^^^^ string.regexp +// ^ string.regexp punctuation.definition.string.begin +/ /* END ERROR */ + + +/** + * https://github.com/babel/babel-sublime/issues/275 + */ + +if (_.startsWith(line, 'State(')) {} +//<- keyword.control.conditional +// ^ meta.group.braces.round meta.brace.round.begin +// ^ meta.group.braces.round variable.other.object variable.other.object +// ^ meta.group.braces.round keyword.operator.accessor +// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.round meta.method +// ^^^^^^^^^^ meta.group.braces.round meta.method string.unquoted entity.name.function +// ^ meta.group.braces.round meta.method punctuation.definition.parameters.begin +// ^^^^ meta.group.braces.round meta.method variable.parameter.function +// ^ meta.group.braces.round meta.method punctuation.separator.parameter.function +// ^^^^^ meta.group.braces.round meta.method variable.parameter.function +// ^ meta.group.braces.round meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.round meta.brace.round.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + + +/** + * https://github.com/babel/babel-sublime/issues/284 + */ + +@web.controller('/hello') +//^ tag.decorator entity.name.tag +//<- tag.decorator punctuation.definition.tag +// ^ keyword.operator.accessor +// ^^^^^^^^^^ meta.function-call.method.with-arguments variable.function +// ^ meta.group.braces.round meta.brace.round.begin +// ^^^^^^^^ meta.group.braces.round string.quoted +// ^ meta.group.braces.round string.quoted punctuation.definition.string.begin +// ^ meta.group.braces.round string.quoted punctuation.definition.string.end +// ^ meta.group.braces.round meta.brace.round.end +class Klass { +//^^^ storage.type.class +// ^^^^^ entity.name.class +// ^ meta.brace.curly.begin + @web.get() +//^ tag.decorator punctuation.definition.tag +// ^^^ tag.decorator entity.name.tag +// ^^^ meta.class-method string.unquoted entity.name.function +// ^ meta.class-method punctuation.definition.parameters.begin +// ^ meta.class-method punctuation.definition.parameters.end + foo(a, b) {} +// ^ meta.class-method punctuation.definition.parameters.begin +// ^ meta.class-method variable.parameter.function +// ^ meta.class-method punctuation.separator.parameter.function +// ^ meta.class-method variable.parameter.function +// ^ meta.class-method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + + @web.use +//^ tag.decorator punctuation.definition.tag +// ^^^ tag.decorator entity.name.tag + bar(c, d) {} +//^^^^^^^^^ meta.class-method +//^^^ meta.class-method string.unquoted entity.name.function +// ^ meta.class-method punctuation.definition.parameters.begin +// ^ meta.class-method variable.parameter.function +// ^ meta.class-method punctuation.separator.parameter.function +// ^ meta.class-method variable.parameter.function +// ^ meta.class-method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +} +//<- meta.class meta.brace.curly.end diff --git a/Packages/JSX/test/syntax_test_js_babel_OLD.js b/Packages/JSX/test/syntax_test_js_babel_OLD.js new file mode 100644 index 0000000..eb32dd2 --- /dev/null +++ b/Packages/JSX/test/syntax_test_js_babel_OLD.js @@ -0,0 +1,3187 @@ +// SYNTAX TEST "Packages/babel-sublime/JavaScript (Babel).tmLanguage" + +class MyClass { +//^^^ meta.class storage.type.class +// ^^^^^^^ meta.class entity.name.class +// ^ meta.class meta.brace.curly.begin + + type: string; +//^^^^ meta.class meta.class.property variable.other.property +// ^^^^^^^^ meta.class meta.class.property meta.flowtype.annotation +// ^ meta.class meta.class.property meta.flowtype.annotation keyword.operator.flowtype.annotation +// ^^^^^^ meta.class meta.class.property meta.flowtype.annotation constant.other.primitve.flowtype + + type: () => void; +//^^^^ meta.class meta.class.property variable.other.property +// ^^^^^^^^^^^^ meta.class meta.class.property meta.flowtype.annotation +// ^ meta.class meta.class.property meta.flowtype.annotation keyword.operator.flowtype.annotation +// ^ meta.class meta.class.property meta.flowtype.annotation punctuation.section.flowtype.begin +// ^ meta.class meta.class.property meta.flowtype.annotation punctuation.section.flowtype.end +// ^^^^^^^ meta.class meta.class.property meta.flowtype.annotation meta.flowtype.function +// ^^ meta.class meta.class.property meta.flowtype.annotation meta.flowtype.function keyword.operator.flowtype +// ^^^^ meta.class meta.class.property meta.flowtype.annotation meta.flowtype.function constant.other.primitve.flowtype + + @@iterator(): Iterator<[K, V]>; +//^^^^^^^^^^ meta.class meta.short-method.flowtype keyword.operator.flowtype +// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.begin +// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.end +// ^^^^^^^^^^^^^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation +// ^^^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype +// ^^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.begin +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype +// ^^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.end + + static (o: ?void): {[key: any]: any}; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class meta.short-method.flowtype +//^^^^^^ meta.class meta.short-method.flowtype keyword.operator.flowtype +// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.begin +// ^ meta.class meta.short-method.flowtype variable.parameter.function +// ^^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.other +// ^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation constant.other.primitve.flowtype +// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.end +// ^^^^^^^^^^^^^^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation +// ^^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.begin +// ^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.other +// ^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation constant.other.primitve.flowtype +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.end +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.other +// ^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation constant.other.primitve.flowtype +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.end + + return(value: R): { done: true, value: R }; +//^^^^^^ meta.class meta.short-method.flowtype keyword.operator.flowtype +// ^ meta.class meta.short-method.flowtype meta.flowtype.polymorph punctuation.section.flowtype.begin +// ^ meta.class meta.short-method.flowtype meta.flowtype.polymorph variable.other.flowtype +// ^ meta.class meta.short-method.flowtype meta.flowtype.polymorph punctuation.section.flowtype.end +// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.begin +// ^^^^^ meta.class meta.short-method.flowtype variable.parameter.function +// ^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype +// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.end +// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.begin +// ^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.other +// ^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype +// ^^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.other +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.end + + (o: T): T; +//^^^^^^^^^^^^^^^^^^^^ meta.class meta.short-method.flowtype +//^^^^^^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.polymorph +//^ meta.class meta.short-method.flowtype meta.flowtype.polymorph punctuation.section.flowtype.begin +// ^ meta.class meta.short-method.flowtype meta.flowtype.polymorph variable.other.flowtype +// ^ meta.class meta.short-method.flowtype meta.flowtype.polymorph keyword.operator.flowtype.other +// ^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.polymorph support.class.builtin +// ^ meta.class meta.short-method.flowtype meta.flowtype.polymorph punctuation.section.flowtype.end +// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.begin +// ^ meta.class meta.short-method.flowtype variable.parameter.function +// ^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype +// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.end +// ^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation +// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype + + regularMethod() {} +//^^^^^^^^^^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + + *generatorMethod() {} +//^ meta.class keyword.generator.asterisk +// ^^^^^^^^^^^^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + + static staticRegularMethod() {} +//^^^^^^ meta.class storage.modifier +// ^^^^^^^^^^^^^^^^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + + static get staticGetterMethod() {} +//^^^^^^ meta.class storage.modifier +// ^^^^ meta.class meta.class-accessor storage.type +// ^^^^^^^^^^^^^^^^^^ meta.class meta.class-accessor string.unquoted entity.name.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin +// ^ meta.class meta.class-accessor punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + + static set staticSetterMethod(arg) {} +//^^^^^^ meta.class storage.modifier +// ^^^^ meta.class meta.class-accessor storage.type +// ^^^^^^^^^^^^^^^^^^ meta.class meta.class-accessor string.unquoted entity.name.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-accessor variable.parameter.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + + static *staticGeneratorMethod() {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class keyword.generator.asterisk +// ^^^^^^^^^^^^^^^^^^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static async staticAsyncMethod() {} +//^^^^^^ meta.class storage.modifier +// ^^^^^ meta.class storage.type +// ^^^^^^^^^^^^^^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + + async asyncMethod() {} +//^^^^^ meta.class storage.type +// ^^^^^^^^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + [computedMethod()]() {} +//^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^^^^^^^^^^^ meta.class meta.group.braces.square meta.function-call.without-arguments variable.function +// ^^ meta.class meta.group.braces.square meta.function-call.without-arguments meta.group.braces.round.function.arguments +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + ["computedString"]() {} +//^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^^^^^^^^^^^^^ meta.class meta.group.braces.square string.quoted +// ^ meta.class meta.group.braces.square string.quoted punctuation.definition.string.begin +// ^ meta.class meta.group.braces.square string.quoted punctuation.definition.string.end +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + + ["computed" + "String"]() {} +//^^^^^^^^^^^^^^^^^^^^^^^ meta.class meta.group.braces.square +//^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^^^^^^^ meta.class meta.group.braces.square string.quoted +// ^ meta.class meta.group.braces.square string.quoted punctuation.definition.string.begin +// ^ meta.class meta.group.braces.square string.quoted punctuation.definition.string.end +// ^ meta.class meta.group.braces.square keyword.operator.arithmetic +// ^^^^^^^^ meta.class meta.group.braces.square string.quoted +// ^ meta.class meta.group.braces.square string.quoted punctuation.definition.string.begin +// ^ meta.class meta.group.braces.square string.quoted punctuation.definition.string.end +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + + *[Symbol.iterator]() {} +//^ meta.class keyword.generator.asterisk +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^^^ meta.class meta.group.braces.square support.class.builtin +// ^ meta.class meta.group.braces.square keyword.operator.accessor +// ^^^^^^^^ meta.class meta.group.braces.square meta.property.object variable.other.property +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end +} + + + +let Sound = { +//^ storage.type +//<- source.js +// ^^^^^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^ meta.group.braces.curly meta.brace.curly.begin + + get() {}, +//^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + get(arg) {}, +//^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.method variable.parameter.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + set() {}, +//^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + set(arg) {}, +//^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.method variable.parameter.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play() {}, +//^^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play(arg) {}, +//^^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.method variable.parameter.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + 'play'() {}, +//^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + 'play'(arg) {}, +//^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.method variable.parameter.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + *play() {}, +//^ meta.group.braces.curly meta.method keyword.generator.asterisk +// ^^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + *play(arg) {}, +//^ meta.group.braces.curly meta.method keyword.generator.asterisk +// ^^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.method variable.parameter.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + async play() {}, +//^^^^^^^^^^^^ meta.group.braces.curly meta.method +//^^^^^ meta.group.braces.curly meta.method storage.type +// ^^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + async play(arg) {}, +//^^^^^^^^^^^^^^^ meta.group.braces.curly meta.method +//^^^^^ meta.group.braces.curly meta.method storage.type +// ^^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.method variable.parameter.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + get play() {}, +//^^^^^^^^^^ meta.group.braces.curly meta.accessor +//^^^ meta.group.braces.curly meta.accessor storage.type.accessor +// ^^^^ meta.group.braces.curly meta.accessor entity.name.accessor +// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + set play(arg) {}, +//^^^^^^^^^^^^^ meta.group.braces.curly meta.accessor +//^^^ meta.group.braces.curly meta.accessor storage.type.accessor +// ^^^^ meta.group.braces.curly meta.accessor entity.name.accessor +// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.accessor variable.parameter.function +// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + *'play'() {}, +//^ meta.group.braces.curly meta.method keyword.generator.asterisk +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + *'play'(arg) {}, +//^ meta.group.braces.curly meta.method keyword.generator.asterisk +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.method variable.parameter.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + async 'play'() {}, +//^^^^^^^^^^^^^^ meta.group.braces.curly meta.method +//^^^^^ meta.group.braces.curly meta.method storage.type +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + async 'play'(arg) {}, +//^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.method +//^^^^^ meta.group.braces.curly meta.method storage.type +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.method variable.parameter.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + get 'play'() {}, +//^^^ meta.group.braces.curly variable.other.readwrite +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + set 'play'(arg) {}, +//^^^ meta.group.braces.curly variable.other.readwrite +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function +// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.method variable.parameter.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [Play.name()]() {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class +// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function +// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [Play.name()[]](arg) {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class +// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function +// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments +// ^ meta.group.braces.curly meta.group.braces.square meta.group.braces.square meta.brace.square.begin +// ^^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly meta.group.braces.square meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin +// ^^^ meta.group.braces.curly meta.group.braces.round variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + *[Play.name()]() {}, +//^ meta.group.braces.curly keyword.operator.arithmetic +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class +// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function +// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + *[Play.name()](arg) {}, +//^ meta.group.braces.curly keyword.operator.arithmetic +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class +// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function +// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin +// ^^^ meta.group.braces.curly meta.group.braces.round variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + async [Play.name()]() {}, +//^^^^^^ meta.group.braces.curly variable.other.object +//^^^^^ meta.group.braces.curly variable.other.object variable.other.object +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class +// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function +// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + async [Play.name()](arg) {}, +//^^^^^^ meta.group.braces.curly variable.other.object +//^^^^^ meta.group.braces.curly variable.other.object variable.other.object +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class +// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function +// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin +// ^^^ meta.group.braces.curly meta.group.braces.round variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + get [Play.name()]() {}, +//^^^^ meta.group.braces.curly variable.other.object +//^^^ meta.group.braces.curly variable.other.object variable.other.object +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class +// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function +// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + set [Play.name()](arg) {}, +//^^^^ meta.group.braces.curly variable.other.object +//^^^ meta.group.braces.curly variable.other.object variable.other.object +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class +// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor +// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function +// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin +// ^^^ meta.group.braces.curly meta.group.braces.round variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + 0() {}, +//^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + 0(arg) {}, +//^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.method variable.parameter.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + *0() {}, +//^ meta.group.braces.curly meta.method keyword.generator.asterisk +// ^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + *0(arg) {}, +//^ meta.group.braces.curly meta.method keyword.generator.asterisk +// ^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.method variable.parameter.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + async 0() {}, +//^^^^^^^^^ meta.group.braces.curly meta.method +//^^^^^ meta.group.braces.curly meta.method storage.type +// ^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + async 0(arg) {}, +//^^^^^^^^^^^^ meta.group.braces.curly meta.method +//^^^^^ meta.group.braces.curly meta.method storage.type +// ^ meta.group.braces.curly meta.method string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.method variable.parameter.function +// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + get 0() {}, +//^^^^^^^ meta.group.braces.curly meta.accessor +//^^^ meta.group.braces.curly meta.accessor storage.type.accessor +// ^ meta.group.braces.curly meta.accessor entity.name.accessor +// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + set 0(arg) {}, +//^^^^^^^^^^ meta.group.braces.curly meta.accessor +//^^^ meta.group.braces.curly meta.accessor storage.type.accessor +// ^ meta.group.braces.curly meta.accessor entity.name.accessor +// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.accessor variable.parameter.function +// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: function() {}, +//^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: function(arg) {}, +//^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: function*() {}, +//^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: function*(arg) {}, +//^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: async function() {}, +//^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json storage.type +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: async function(arg) {}, +//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json storage.type +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: async function*() {}, +//^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json storage.type +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: async function*(arg) {}, +//^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json storage.type +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: async () => {}, +//^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow +//^^^^ meta.group.braces.curly meta.function.json.arrow string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json.arrow storage.type +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end +// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: async (arg) => {}, +//^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow +//^^^^ meta.group.braces.curly meta.function.json.arrow string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json.arrow storage.type +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end +// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: async arg => {}, +//^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow +//^^^^ meta.group.braces.curly meta.function.json.arrow string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json.arrow storage.type +// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function +// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: () => {}, +//^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow +//^^^^ meta.group.braces.curly meta.function.json.arrow string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end +// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: (arg) => {}, +//^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow +//^^^^ meta.group.braces.curly meta.function.json.arrow string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end +// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + play: arg => {}, +//^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow +//^^^^ meta.group.braces.curly meta.function.json.arrow string.unquoted entity.name.function +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value +// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function +// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": function() {}, +//^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": function(arg) {}, +//^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": function*() {}, +//^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": function*(arg) {}, +//^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": async function() {}, +//^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json storage.type +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": async function(arg) {}, +//^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json storage.type +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": async function*() {}, +//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json storage.type +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": async function*(arg) {}, +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json +//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json storage.type +// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function +// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function +// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": async () => {}, +//^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow +//^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json.arrow string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json.arrow storage.type +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end +// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": async (arg) => {}, +//^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow +//^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json.arrow string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json.arrow storage.type +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end +// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": async arg => {}, +//^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow +//^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json.arrow string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.json.arrow storage.type +// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function +// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": () => {}, +//^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow +//^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json.arrow string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end +// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": (arg) => {}, +//^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow +//^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json.arrow string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end +// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + "play": arg => {}, +//^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow +//^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.begin +// ^^^^ meta.group.braces.curly meta.function.json.arrow string.quoted entity.name.function +// ^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.end +// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value +// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function +// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: function() {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: function(arg) {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function variable.parameter.function +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: function*() {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function +// ^ meta.group.braces.curly meta.function keyword.generator.asterisk +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: function*(arg) {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function +// ^ meta.group.braces.curly meta.function keyword.generator.asterisk +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function variable.parameter.function +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: async function() {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function +// ^^^^^ meta.group.braces.curly meta.function storage.type +// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: async function(arg) {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function +// ^^^^^ meta.group.braces.curly meta.function storage.type +// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function variable.parameter.function +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: async function*() {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function +// ^^^^^ meta.group.braces.curly meta.function storage.type +// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function +// ^ meta.group.braces.curly meta.function keyword.generator.asterisk +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: async function*(arg) {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function +// ^^^^^ meta.group.braces.curly meta.function storage.type +// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function +// ^ meta.group.braces.curly meta.function keyword.generator.asterisk +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function variable.parameter.function +// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: async () => {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^^^^^^^ meta.group.braces.curly meta.function.arrow +// ^^^^^ meta.group.braces.curly meta.function.arrow storage.type +// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.group.braces.curly meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: async (arg) => {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.arrow +// ^^^^^ meta.group.braces.curly meta.function.arrow storage.type +// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.arrow variable.parameter.function +// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.group.braces.curly meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: async arg => {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^^^^^^^^ meta.group.braces.curly meta.function.arrow +// ^^^^^ meta.group.braces.curly meta.function.arrow storage.type +// ^^^ meta.group.braces.curly meta.function.arrow variable.parameter.function +// ^^ meta.group.braces.curly meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: () => {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^ meta.group.braces.curly meta.function.arrow +// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.begin +// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.group.braces.curly meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: (arg) => {}, +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^^^^ meta.group.braces.curly meta.function.arrow +// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.begin +// ^^^ meta.group.braces.curly meta.function.arrow variable.parameter.function +// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.group.braces.curly meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.delimiter.comma + + [play]: arg => {} +//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.curly punctuation.separator.key-value +// ^^^^^^ meta.group.braces.curly meta.function.arrow +// ^^^ meta.group.braces.curly meta.function.arrow variable.parameter.function +// ^^ meta.group.braces.curly meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end + +} + +class Sound extends Model { +//^^^ meta.class storage.type.class +// ^^^^^ meta.class entity.name.class +// ^^^^^^ meta.class meta.flowtype.polymorph +// ^ meta.class meta.flowtype.polymorph punctuation.section.flowtype.begin +// ^ meta.class meta.flowtype.polymorph variable.other.flowtype +// ^ meta.class meta.flowtype.polymorph variable.other.flowtype +// ^ meta.class meta.flowtype.polymorph punctuation.section.flowtype.end +// ^^^^^^^^^^^^^^^^^^^^ meta.class meta.class.extends +// ^^^^^^^ meta.class meta.class.extends storage.type.extends +// ^^^^^ meta.class meta.class.extends variable.other.readwrite +// ^^^^^^ meta.class meta.class.extends meta.flowtype.polymorph +// ^ meta.class meta.class.extends meta.flowtype.polymorph punctuation.section.flowtype.begin +// ^ meta.class meta.class.extends meta.flowtype.polymorph variable.other.flowtype +// ^ meta.class meta.class.extends meta.flowtype.polymorph variable.other.flowtype +// ^ meta.class meta.class.extends meta.flowtype.polymorph punctuation.section.flowtype.end +// ^ meta.class meta.brace.curly.begin + get() {} +//^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + get(arg) {} +//^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + set() {} +//^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + set(arg) {} +//^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + *get() {} +//^ meta.class keyword.generator.asterisk +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + *get(arg) {} +//^ meta.class keyword.generator.asterisk +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + *set() {} +//^ meta.class keyword.generator.asterisk +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + *set(arg) {} +//^ meta.class keyword.generator.asterisk +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + async get() {} +//^^^^^ meta.class storage.type +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + async get(arg) {} +//^^^^^ meta.class storage.type +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + async set() {} +//^^^^^ meta.class storage.type +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + async set(arg) {} +//^^^^^ meta.class storage.type +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static get() {} +//^^^^^^ meta.class storage.modifier +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static get(arg) {} +//^^^^^^ meta.class storage.modifier +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static set() {} +//^^^^^^ meta.class storage.modifier +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static set(arg) {} +//^^^^^^ meta.class storage.modifier +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static *get() {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class keyword.generator.asterisk +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static *get(arg) {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class keyword.generator.asterisk +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static *set() {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class keyword.generator.asterisk +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static *set(arg) {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class keyword.generator.asterisk +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static async get() {} +//^^^^^^ meta.class storage.modifier +// ^^^^^ meta.class storage.type +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static async get(arg) {} +//^^^^^^ meta.class storage.modifier +// ^^^^^ meta.class storage.type +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static async set() {} +//^^^^^^ meta.class storage.modifier +// ^^^^^ meta.class storage.type +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static async set(arg) {} +//^^^^^^ meta.class storage.modifier +// ^^^^^ meta.class storage.type +// ^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static get get() {} +//^^^^^^ meta.class storage.modifier +// ^^^^ meta.class meta.class-accessor storage.type +// ^^^ meta.class meta.class-accessor string.unquoted entity.name.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin +// ^ meta.class meta.class-accessor punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static set set(arg) {} +//^^^^^^ meta.class storage.modifier +// ^^^^ meta.class meta.class-accessor storage.type +// ^^^ meta.class meta.class-accessor string.unquoted entity.name.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-accessor variable.parameter.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + play() {} +//^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + play(arg) {} +//^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + 'play'() {} +//^ meta.class meta.class-method string.quoted punctuation.definition.string.begin +// ^^^^ meta.class meta.class-method string.quoted entity.name.function +// ^ meta.class meta.class-method string.quoted punctuation.definition.string.end +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + 'play'(arg) {} +//^ meta.class meta.class-method string.quoted punctuation.definition.string.begin +// ^^^^ meta.class meta.class-method string.quoted entity.name.function +// ^ meta.class meta.class-method string.quoted punctuation.definition.string.end +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + *play() {} +//^ meta.class keyword.generator.asterisk +// ^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + *play(arg) {} +//^ meta.class keyword.generator.asterisk +// ^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + *'play'() {} +//^ meta.class keyword.generator.asterisk +// ^ meta.class meta.class-method string.quoted punctuation.definition.string.begin +// ^^^^ meta.class meta.class-method string.quoted entity.name.function +// ^ meta.class meta.class-method string.quoted punctuation.definition.string.end +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + *'play'(arg) {} +//^ meta.class keyword.generator.asterisk +// ^ meta.class meta.class-method string.quoted punctuation.definition.string.begin +// ^^^^ meta.class meta.class-method string.quoted entity.name.function +// ^ meta.class meta.class-method string.quoted punctuation.definition.string.end +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + async play() {} +//^^^^^ meta.class storage.type +// ^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + async play(arg) {} +//^^^^^ meta.class storage.type +// ^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + get play() {} +//^^^^ meta.class meta.class-accessor storage.type +// ^^^^ meta.class meta.class-accessor string.unquoted entity.name.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin +// ^ meta.class meta.class-accessor punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + set play(arg) {} +//^^^^ meta.class meta.class-accessor storage.type +// ^^^^ meta.class meta.class-accessor string.unquoted entity.name.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-accessor variable.parameter.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static play() {} +//^^^^^^ meta.class storage.modifier +// ^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static play(arg) {} +//^^^^^^ meta.class storage.modifier +// ^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static *play() {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class keyword.generator.asterisk +// ^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static *play(arg) {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class keyword.generator.asterisk +// ^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static async play() {} +//^^^^^^ meta.class storage.modifier +// ^^^^^ meta.class storage.type +// ^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static async play(arg) {} +//^^^^^^ meta.class storage.modifier +// ^^^^^ meta.class storage.type +// ^^^^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static get play() {} +//^^^^^^ meta.class storage.modifier +// ^^^^ meta.class meta.class-accessor storage.type +// ^^^^ meta.class meta.class-accessor string.unquoted entity.name.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin +// ^ meta.class meta.class-accessor punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static set play(arg) {} +//^^^^^^ meta.class storage.modifier +// ^^^^ meta.class meta.class-accessor storage.type +// ^^^^ meta.class meta.class-accessor string.unquoted entity.name.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-accessor variable.parameter.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + 0() {} +//^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + 0(arg) {} +//^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + *0() {} +//^ meta.class keyword.generator.asterisk +// ^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + *0(arg) {} +//^ meta.class keyword.generator.asterisk +// ^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + async 0() {} +//^^^^^ meta.class storage.type +// ^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + async 0(arg) {} +//^^^^^ meta.class storage.type +// ^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + get 0() {} +//^^^^ meta.class meta.class-accessor storage.type +// ^ meta.class meta.class-accessor string.unquoted entity.name.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin +// ^ meta.class meta.class-accessor punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + set 0(arg) {} +//^^^^ meta.class meta.class-accessor storage.type +// ^ meta.class meta.class-accessor string.unquoted entity.name.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-accessor variable.parameter.function +// ^ meta.class meta.class-accessor punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static 0() {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static 0(arg) {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static *0() {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class keyword.generator.asterisk +// ^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static *0(arg) {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class keyword.generator.asterisk +// ^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static async 0() {} +//^^^^^^ meta.class storage.modifier +// ^^^^^ meta.class storage.type +// ^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static async 0(arg) {} +//^^^^^^ meta.class storage.modifier +// ^^^^^ meta.class storage.type +// ^ meta.class meta.class-method string.unquoted entity.name.function +// ^ meta.class meta.class-method punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method variable.parameter.function +// ^ meta.class meta.class-method punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + [play]() {} +//^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + [play](arg) {} +//^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method.computed variable.parameter.function +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + *[play]() {} +//^ meta.class keyword.generator.asterisk +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + *[play](arg) {} +//^ meta.class keyword.generator.asterisk +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method.computed variable.parameter.function +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + async [play]() {} +//^^^^^ meta.class storage.type +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + async [play](arg) {} +//^^^^^ meta.class storage.type +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method.computed variable.parameter.function +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + get [play]() {} +//^^^ meta.class storage.type +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + set [play](arg) {} +//^^^ meta.class storage.type +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method.computed variable.parameter.function +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static [play]() {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static [play](arg) {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method.computed variable.parameter.function +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static *[play]() {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class keyword.generator.asterisk +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static *[play](arg) {} +//^^^^^^ meta.class storage.modifier +// ^ meta.class keyword.generator.asterisk +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method.computed variable.parameter.function +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static async [play]() {} +//^^^^^^ meta.class storage.modifier +// ^^^^^ meta.class storage.type +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static async [play](arg) {} +//^^^^^^ meta.class storage.modifier +// ^^^^^ meta.class storage.type +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method.computed variable.parameter.function +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static get [play]() {} +//^^^^^^ meta.class storage.modifier +// ^^^ meta.class storage.type +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end + static set [play](arg) {} +//^^^^^^ meta.class storage.modifier +// ^^^ meta.class storage.type +// ^ meta.class meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.class meta.group.braces.square variable.other.readwrite +// ^ meta.class meta.group.braces.square meta.brace.square.end +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin +// ^^^ meta.class meta.class-method.computed variable.parameter.function +// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end +// ^ meta.class meta.group.braces.curly meta.brace.curly.begin +// ^ meta.class meta.group.braces.curly meta.brace.curly.end +} +//<- meta.class meta.brace.curly.end + + +Sound +//^^^ variable.other.readwrite +Sound() +//^^^ meta.function-call.without-arguments variable.function +// ^^ meta.function-call.without-arguments meta.group.braces.round.function.arguments +Sound = {} +//^^^ variable.other.readwrite +//<- source.js +// ^ keyword.operator.assignment +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play +//^^^ meta.property.class variable.other.class +// ^ meta.property.class keyword.operator.accessor +// ^^^^ meta.property.class variable.other.property.static +Sound[play] +//^^^ variable.other.object variable.other.object +// ^ meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.square meta.brace.square.end +Sound.play() +//^^^ meta.function-call.static.without-arguments variable.other.class +// ^ meta.function-call.static.without-arguments keyword.operator.accessor +// ^^^^ meta.function-call.static.without-arguments variable.function +// ^^ meta.function-call.static.without-arguments meta.group.braces.round.function.arguments +Sound[play]() +//^^^ variable.other.object variable.other.object +// ^ meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.round meta.brace.round.begin +// ^ meta.group.braces.round meta.brace.round.end +Sound.play = {} +//^^^ meta.property.class variable.other.class +//<- source.js +// ^ meta.property.class keyword.operator.accessor +// ^^^^ meta.property.class variable.other.property.static +// ^ keyword.operator.assignment +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound[play] = {} +//^^^ variable.other.object variable.other.object +//<- source.js +// ^ meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.square meta.brace.square.end +// ^ keyword.operator.assignment +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype +//^^^ meta.prototype.access entity.name.class +// ^ meta.prototype.access keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.access variable.language.prototype +Sound.prototype() +//^^^ meta.prototype.access entity.name.class +// ^ meta.prototype.access keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.access variable.language.prototype +// ^ meta.group.braces.round meta.brace.round.begin +// ^ meta.group.braces.round meta.brace.round.end +Sound.prototype = {} +//^^^^^^^^^^^^^^^^ meta.prototype.declaration +//^^^ meta.prototype.declaration entity.name.class +// ^ meta.prototype.declaration keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.declaration variable.language.prototype +// ^ meta.prototype.declaration keyword.operator.assignment +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play +//^^^ meta.prototype.access entity.name.class +// ^ meta.prototype.access keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.access variable.language.prototype +// ^ keyword.operator.accessor +// ^^^^ meta.property.object variable.other.property +Sound.prototype.play() +//^^^ meta.prototype.access entity.name.class +// ^ meta.prototype.access keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.access variable.language.prototype +// ^ keyword.operator.accessor +// ^^^^ meta.function-call.method.without-arguments variable.function +// ^^ meta.function-call.method.without-arguments meta.group.braces.round.function.arguments +Sound.prototype[play]() +//^^^ meta.prototype.access entity.name.class +// ^ meta.prototype.access keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.access variable.language.prototype +// ^ meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.round meta.brace.round.begin +// ^ meta.group.braces.round meta.brace.round.end +Sound.prototype.play = +//^^^ meta.prototype.access entity.name.class +//<- source.js +// ^ meta.prototype.access keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.access variable.language.prototype +// ^ keyword.operator.accessor +// ^^^^ meta.property.object variable.other.property +// ^ keyword.operator.assignment +Sound.prototype[play] = +//^^^ meta.prototype.access entity.name.class +//<- source.js +// ^ meta.prototype.access keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.access variable.language.prototype +// ^ meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.square meta.brace.square.end +// ^ keyword.operator.assignment +Sound.play.repeat +//^^^ meta.property.class variable.other.class +// ^ meta.property.class keyword.operator.accessor +// ^^^^ meta.property.class variable.other.property.static +// ^ keyword.operator.accessor +// ^^^^^^ meta.property.object variable.other.property +Sound[play].repeat +//^^^ variable.other.object variable.other.object +// ^ meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.square meta.brace.square.end +// ^ keyword.operator.accessor +// ^^^^^^ meta.property.object variable.other.property +Sound.play.repeat() +//^^^ meta.property.class variable.other.class +// ^ meta.property.class keyword.operator.accessor +// ^^^^ meta.property.class variable.other.property.static +// ^ keyword.operator.accessor +// ^^^^^^ meta.function-call.method.without-arguments variable.function +// ^^ meta.function-call.method.without-arguments meta.group.braces.round.function.arguments +Sound[play].repeat() +//^^^ variable.other.object variable.other.object +// ^ meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.square meta.brace.square.end +// ^ keyword.operator.accessor +// ^^^^^^ meta.function-call.method.without-arguments variable.function +// ^^ meta.function-call.method.without-arguments meta.group.braces.round.function.arguments +Sound.play.repeat = {} +//^^^ meta.property.class variable.other.class +//<- source.js +// ^ meta.property.class keyword.operator.accessor +// ^^^^ meta.property.class variable.other.property.static +// ^ keyword.operator.accessor +// ^^^^^^ meta.property.object variable.other.property +// ^ keyword.operator.assignment +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound[play].repeat = {} +//^^^ variable.other.object variable.other.object +//<- source.js +// ^ meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.square meta.brace.square.end +// ^ keyword.operator.accessor +// ^^^^^^ meta.property.object variable.other.property +// ^ keyword.operator.assignment +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + + +Sound.prototype.play = function() {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype +//^^^ meta.function.prototype entity.name.class +//<- source.js +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^^^^^^ meta.function.prototype variable.language.prototype +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype keyword.operator.assignment +// ^^^^^^^^ meta.function.prototype storage.type.function +// ^ meta.function.prototype punctuation.definition.parameters.begin +// ^ meta.function.prototype punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play = function(arg) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype +//^^^ meta.function.prototype entity.name.class +//<- source.js +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^^^^^^ meta.function.prototype variable.language.prototype +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype keyword.operator.assignment +// ^^^^^^^^ meta.function.prototype storage.type.function +// ^ meta.function.prototype punctuation.definition.parameters.begin +// ^^^ meta.function.prototype variable.parameter.function +// ^ meta.function.prototype punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play = function*() {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype +//^^^ meta.function.prototype entity.name.class +//<- source.js +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^^^^^^ meta.function.prototype variable.language.prototype +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype keyword.operator.assignment +// ^^^^^^^^ meta.function.prototype storage.type.function +// ^ meta.function.prototype keyword.generator.asterisk +// ^ meta.function.prototype punctuation.definition.parameters.begin +// ^ meta.function.prototype punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play = function*(arg) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype +//^^^ meta.function.prototype entity.name.class +//<- source.js +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^^^^^^ meta.function.prototype variable.language.prototype +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype keyword.operator.assignment +// ^^^^^^^^ meta.function.prototype storage.type.function +// ^ meta.function.prototype keyword.generator.asterisk +// ^ meta.function.prototype punctuation.definition.parameters.begin +// ^^^ meta.function.prototype variable.parameter.function +// ^ meta.function.prototype punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play = async function() {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype +//^^^ meta.function.prototype entity.name.class +//<- source.js +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^^^^^^ meta.function.prototype variable.language.prototype +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype keyword.operator.assignment +// ^^^^^ meta.function.prototype storage.type +// ^^^^^^^^ meta.function.prototype storage.type.function +// ^ meta.function.prototype punctuation.definition.parameters.begin +// ^ meta.function.prototype punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play = async function(arg) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype +//^^^ meta.function.prototype entity.name.class +//<- source.js +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^^^^^^ meta.function.prototype variable.language.prototype +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype keyword.operator.assignment +// ^^^^^ meta.function.prototype storage.type +// ^^^^^^^^ meta.function.prototype storage.type.function +// ^ meta.function.prototype punctuation.definition.parameters.begin +// ^^^ meta.function.prototype variable.parameter.function +// ^ meta.function.prototype punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play = async function*() {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype +//^^^ meta.function.prototype entity.name.class +//<- source.js +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^^^^^^ meta.function.prototype variable.language.prototype +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype keyword.operator.assignment +// ^^^^^ meta.function.prototype storage.type +// ^^^^^^^^ meta.function.prototype storage.type.function +// ^ meta.function.prototype keyword.generator.asterisk +// ^ meta.function.prototype punctuation.definition.parameters.begin +// ^ meta.function.prototype punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play = async function*(arg) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype +//^^^ meta.function.prototype entity.name.class +//<- source.js +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^^^^^^ meta.function.prototype variable.language.prototype +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype keyword.operator.assignment +// ^^^^^ meta.function.prototype storage.type +// ^^^^^^^^ meta.function.prototype storage.type.function +// ^ meta.function.prototype keyword.generator.asterisk +// ^ meta.function.prototype punctuation.definition.parameters.begin +// ^^^ meta.function.prototype variable.parameter.function +// ^ meta.function.prototype punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play = async () => {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow +//^^^ meta.prototype.function.arrow entity.name.class +//<- source.js +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^ meta.prototype.function.arrow entity.name.function +// ^ meta.prototype.function.arrow keyword.operator.assignment +// ^^^^^ meta.prototype.function.arrow storage.type +// ^ meta.prototype.function.arrow punctuation.definition.parameters.begin +// ^ meta.prototype.function.arrow punctuation.definition.parameters.end +// ^^ meta.prototype.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play = async (arg) => {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow +//^^^ meta.prototype.function.arrow entity.name.class +//<- source.js +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^ meta.prototype.function.arrow entity.name.function +// ^ meta.prototype.function.arrow keyword.operator.assignment +// ^^^^^ meta.prototype.function.arrow storage.type +// ^ meta.prototype.function.arrow punctuation.definition.parameters.begin +// ^^^ meta.prototype.function.arrow variable.parameter.function +// ^ meta.prototype.function.arrow punctuation.definition.parameters.end +// ^^ meta.prototype.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play = async arg => {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow +//^^^ meta.prototype.function.arrow entity.name.class +//<- source.js +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^ meta.prototype.function.arrow entity.name.function +// ^ meta.prototype.function.arrow keyword.operator.assignment +// ^^^^^ meta.prototype.function.arrow storage.type +// ^^^ meta.prototype.function.arrow variable.parameter.function +// ^^ meta.prototype.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play = () => {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow +//^^^ meta.prototype.function.arrow entity.name.class +//<- source.js +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^ meta.prototype.function.arrow entity.name.function +// ^ meta.prototype.function.arrow keyword.operator.assignment +// ^ meta.prototype.function.arrow punctuation.definition.parameters.begin +// ^ meta.prototype.function.arrow punctuation.definition.parameters.end +// ^^ meta.prototype.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play = (arg) => {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow +//^^^ meta.prototype.function.arrow entity.name.class +//<- source.js +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^ meta.prototype.function.arrow entity.name.function +// ^ meta.prototype.function.arrow keyword.operator.assignment +// ^ meta.prototype.function.arrow punctuation.definition.parameters.begin +// ^^^ meta.prototype.function.arrow variable.parameter.function +// ^ meta.prototype.function.arrow punctuation.definition.parameters.end +// ^^ meta.prototype.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.play = arg => {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow +//^^^ meta.prototype.function.arrow entity.name.class +//<- source.js +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^ meta.prototype.function.arrow entity.name.function +// ^ meta.prototype.function.arrow keyword.operator.assignment +// ^^^ meta.prototype.function.arrow variable.parameter.function +// ^^ meta.prototype.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + + +Sound.play = function() {} +//^^^^^^^^^^^^^^^^^^^^^ meta.function.static +//^^^ meta.function.static entity.name.class +//<- source.js +// ^ meta.function.static keyword.operator.accessor +// ^^^^ meta.function.static entity.name.function +// ^ meta.function.static keyword.operator.assignment +// ^^^^^^^^ meta.function.static storage.type.function +// ^ meta.function.static punctuation.definition.parameters.begin +// ^ meta.function.static punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play = function(arg) {} +//^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static +//^^^ meta.function.static entity.name.class +//<- source.js +// ^ meta.function.static keyword.operator.accessor +// ^^^^ meta.function.static entity.name.function +// ^ meta.function.static keyword.operator.assignment +// ^^^^^^^^ meta.function.static storage.type.function +// ^ meta.function.static punctuation.definition.parameters.begin +// ^^^ meta.function.static variable.parameter.function +// ^ meta.function.static punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play = function*() {} +//^^^^^^^^^^^^^^^^^^^^^^ meta.function.static +//^^^ meta.function.static entity.name.class +//<- source.js +// ^ meta.function.static keyword.operator.accessor +// ^^^^ meta.function.static entity.name.function +// ^ meta.function.static keyword.operator.assignment +// ^^^^^^^^ meta.function.static storage.type.function +// ^ meta.function.static keyword.generator.asterisk +// ^ meta.function.static punctuation.definition.parameters.begin +// ^ meta.function.static punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play = function*(arg) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static +//^^^ meta.function.static entity.name.class +//<- source.js +// ^ meta.function.static keyword.operator.accessor +// ^^^^ meta.function.static entity.name.function +// ^ meta.function.static keyword.operator.assignment +// ^^^^^^^^ meta.function.static storage.type.function +// ^ meta.function.static keyword.generator.asterisk +// ^ meta.function.static punctuation.definition.parameters.begin +// ^^^ meta.function.static variable.parameter.function +// ^ meta.function.static punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play = async function() {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static +//^^^ meta.function.static entity.name.class +//<- source.js +// ^ meta.function.static keyword.operator.accessor +// ^^^^ meta.function.static entity.name.function +// ^ meta.function.static keyword.operator.assignment +// ^^^^^ meta.function.static storage.type +// ^^^^^^^^ meta.function.static storage.type.function +// ^ meta.function.static punctuation.definition.parameters.begin +// ^ meta.function.static punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play = async function(arg) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static +//^^^ meta.function.static entity.name.class +//<- source.js +// ^ meta.function.static keyword.operator.accessor +// ^^^^ meta.function.static entity.name.function +// ^ meta.function.static keyword.operator.assignment +// ^^^^^ meta.function.static storage.type +// ^^^^^^^^ meta.function.static storage.type.function +// ^ meta.function.static punctuation.definition.parameters.begin +// ^^^ meta.function.static variable.parameter.function +// ^ meta.function.static punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play = async function*() {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static +//^^^ meta.function.static entity.name.class +//<- source.js +// ^ meta.function.static keyword.operator.accessor +// ^^^^ meta.function.static entity.name.function +// ^ meta.function.static keyword.operator.assignment +// ^^^^^ meta.function.static storage.type +// ^^^^^^^^ meta.function.static storage.type.function +// ^ meta.function.static keyword.generator.asterisk +// ^ meta.function.static punctuation.definition.parameters.begin +// ^ meta.function.static punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play = async function*(arg) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static +//^^^ meta.function.static entity.name.class +//<- source.js +// ^ meta.function.static keyword.operator.accessor +// ^^^^ meta.function.static entity.name.function +// ^ meta.function.static keyword.operator.assignment +// ^^^^^ meta.function.static storage.type +// ^^^^^^^^ meta.function.static storage.type.function +// ^ meta.function.static keyword.generator.asterisk +// ^ meta.function.static punctuation.definition.parameters.begin +// ^^^ meta.function.static variable.parameter.function +// ^ meta.function.static punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play = async () => {} +//^^^^^^^^^^^^^^^^^^^^^^ meta.function.static.arrow +//^^^ meta.function.static.arrow entity.name.class +//<- source.js +// ^ meta.function.static.arrow keyword.operator.accessor +// ^^^^ meta.function.static.arrow entity.name.function +// ^ meta.function.static.arrow keyword.operator.assignment +// ^^^^^ meta.function.static.arrow storage.type +// ^ meta.function.static.arrow punctuation.definition.parameters.begin +// ^ meta.function.static.arrow punctuation.definition.parameters.end +// ^^ meta.function.static.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play = async (arg) => {} +//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static.arrow +//^^^ meta.function.static.arrow entity.name.class +//<- source.js +// ^ meta.function.static.arrow keyword.operator.accessor +// ^^^^ meta.function.static.arrow entity.name.function +// ^ meta.function.static.arrow keyword.operator.assignment +// ^^^^^ meta.function.static.arrow storage.type +// ^ meta.function.static.arrow punctuation.definition.parameters.begin +// ^^^ meta.function.static.arrow variable.parameter.function +// ^ meta.function.static.arrow punctuation.definition.parameters.end +// ^^ meta.function.static.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play = async arg => {} +//^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static.arrow +//^^^ meta.function.static.arrow entity.name.class +//<- source.js +// ^ meta.function.static.arrow keyword.operator.accessor +// ^^^^ meta.function.static.arrow entity.name.function +// ^ meta.function.static.arrow keyword.operator.assignment +// ^^^^^ meta.function.static.arrow storage.type +// ^^^ meta.function.static.arrow variable.parameter.function +// ^^ meta.function.static.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play = () => {} +//^^^^^^^^^^^^^^^^ meta.function.static.arrow +//^^^ meta.function.static.arrow entity.name.class +//<- source.js +// ^ meta.function.static.arrow keyword.operator.accessor +// ^^^^ meta.function.static.arrow entity.name.function +// ^ meta.function.static.arrow keyword.operator.assignment +// ^ meta.function.static.arrow punctuation.definition.parameters.begin +// ^ meta.function.static.arrow punctuation.definition.parameters.end +// ^^ meta.function.static.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play = (arg) => {} +//^^^^^^^^^^^^^^^^^^^ meta.function.static.arrow +//^^^ meta.function.static.arrow entity.name.class +//<- source.js +// ^ meta.function.static.arrow keyword.operator.accessor +// ^^^^ meta.function.static.arrow entity.name.function +// ^ meta.function.static.arrow keyword.operator.assignment +// ^ meta.function.static.arrow punctuation.definition.parameters.begin +// ^^^ meta.function.static.arrow variable.parameter.function +// ^ meta.function.static.arrow punctuation.definition.parameters.end +// ^^ meta.function.static.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.play = arg => {} +//^^^^^^^^^^^^^^^^^ meta.function.static.arrow +//^^^ meta.function.static.arrow entity.name.class +//<- source.js +// ^ meta.function.static.arrow keyword.operator.accessor +// ^^^^ meta.function.static.arrow entity.name.function +// ^ meta.function.static.arrow keyword.operator.assignment +// ^^^ meta.function.static.arrow variable.parameter.function +// ^^ meta.function.static.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +play = function() {} +//^^^^^^^^^^^^^^^ meta.function +//^^ meta.function entity.name.function +//<- source.js +// ^ meta.function keyword.operator.assignment +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +play = function(arg) {} +//^^^^^^^^^^^^^^^^^^ meta.function +//^^ meta.function entity.name.function +//<- source.js +// ^ meta.function keyword.operator.assignment +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function punctuation.definition.parameters.begin +// ^^^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +play = function*() {} +//^^^^^^^^^^^^^^^^ meta.function +//^^ meta.function entity.name.function +//<- source.js +// ^ meta.function keyword.operator.assignment +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function keyword.generator.asterisk +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +play = function*(arg) {} +//^^^^^^^^^^^^^^^^^^^ meta.function +//^^ meta.function entity.name.function +//<- source.js +// ^ meta.function keyword.operator.assignment +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function keyword.generator.asterisk +// ^ meta.function punctuation.definition.parameters.begin +// ^^^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +play = async function() {} +//^^^^^^^^^^^^^^^^^^^^^ meta.function +//^^ meta.function entity.name.function +//<- source.js +// ^ meta.function keyword.operator.assignment +// ^^^^^ meta.function storage.type +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +play = async function(arg) {} +//^^^^^^^^^^^^^^^^^^^^^^^^ meta.function +//^^ meta.function entity.name.function +//<- source.js +// ^ meta.function keyword.operator.assignment +// ^^^^^ meta.function storage.type +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function punctuation.definition.parameters.begin +// ^^^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +play = async function*() {} +//^^^^^^^^^^^^^^^^^^^^^^ meta.function +//^^ meta.function entity.name.function +//<- source.js +// ^ meta.function keyword.operator.assignment +// ^^^^^ meta.function storage.type +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function keyword.generator.asterisk +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +play = async function*(arg) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function +//^^ meta.function entity.name.function +//<- source.js +// ^ meta.function keyword.operator.assignment +// ^^^^^ meta.function storage.type +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function keyword.generator.asterisk +// ^ meta.function punctuation.definition.parameters.begin +// ^^^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +play = async () => {} +//^^^^^^^^^^^^^^^^ meta.function.arrow +//^^ meta.function.arrow entity.name.function +//<- source.js +// ^ meta.function.arrow keyword.operator.assignment +// ^^^^^ meta.function.arrow storage.type +// ^ meta.function.arrow punctuation.definition.parameters.begin +// ^ meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +play = async (arg) => {} +//^^^^^^^^^^^^^^^^^^^ meta.function.arrow +//^^ meta.function.arrow entity.name.function +//<- source.js +// ^ meta.function.arrow keyword.operator.assignment +// ^^^^^ meta.function.arrow storage.type +// ^ meta.function.arrow punctuation.definition.parameters.begin +// ^^^ meta.function.arrow variable.parameter.function +// ^ meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +play = async arg => {} +//^^^^^^^^^^^^^^^^^ meta.function.arrow +//^^ meta.function.arrow entity.name.function +//<- source.js +// ^ meta.function.arrow keyword.operator.assignment +// ^^^^^ meta.function.arrow storage.type +// ^^^ meta.function.arrow variable.parameter.function +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +play = () => {} +//^^^^^^^^^^ meta.function.arrow +//^^ meta.function.arrow entity.name.function +//<- source.js +// ^ meta.function.arrow keyword.operator.assignment +// ^ meta.function.arrow punctuation.definition.parameters.begin +// ^ meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +play = (arg) => {} +//^^^^^^^^^^^^^ meta.function.arrow +//^^ meta.function.arrow entity.name.function +//<- source.js +// ^ meta.function.arrow keyword.operator.assignment +// ^ meta.function.arrow punctuation.definition.parameters.begin +// ^^^ meta.function.arrow variable.parameter.function +// ^ meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +play = arg => {} +//^^^^^^^^^^^ meta.function.arrow +//^^ meta.function.arrow entity.name.function +//<- source.js +// ^ meta.function.arrow keyword.operator.assignment +// ^^^ meta.function.arrow variable.parameter.function +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + + +return function() {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return function(arg) {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function punctuation.definition.parameters.begin +// ^^^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return function*() {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function keyword.generator.asterisk +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return function*(arg) {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function keyword.generator.asterisk +// ^ meta.function punctuation.definition.parameters.begin +// ^^^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return async function() {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^^^^^ meta.function +// ^^^^^ meta.function storage.type +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return async function(arg) {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^^^^^^^^ meta.function +// ^^^^^ meta.function storage.type +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function punctuation.definition.parameters.begin +// ^^^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return async function*() {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^^^^^^ meta.function +// ^^^^^ meta.function storage.type +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function keyword.generator.asterisk +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return async function*(arg) {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^^^^^^^^^ meta.function +// ^^^^^ meta.function storage.type +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function keyword.generator.asterisk +// ^ meta.function punctuation.definition.parameters.begin +// ^^^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return async () => {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^ meta.function.arrow +// ^^^^^ meta.function.arrow storage.type +// ^ meta.function.arrow punctuation.definition.parameters.begin +// ^ meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return async (arg) => {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^^^ meta.function.arrow +// ^^^^^ meta.function.arrow storage.type +// ^ meta.function.arrow punctuation.definition.parameters.begin +// ^^^ meta.function.arrow variable.parameter.function +// ^ meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return async arg => {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^ meta.function.arrow +// ^^^^^ meta.function.arrow storage.type +// ^^^ meta.function.arrow variable.parameter.function +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return () => {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^ meta.function.arrow +// ^ meta.function.arrow punctuation.definition.parameters.begin +// ^ meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return (arg) => {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^ meta.function.arrow +// ^ meta.function.arrow punctuation.definition.parameters.begin +// ^^^ meta.function.arrow variable.parameter.function +// ^ meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return arg => {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^ meta.function.arrow +// ^^^ meta.function.arrow variable.parameter.function +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +return function play() {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^^^^ meta.function +// ^^^^^^^^ meta.function storage.type.function +// ^^^^ meta.function entity.name.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return function play(arg) {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^^^^^^^ meta.function +// ^^^^^^^^ meta.function storage.type.function +// ^^^^ meta.function entity.name.function +// ^ meta.function punctuation.definition.parameters.begin +// ^^^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return function* play() {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^^^^^ meta.function +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function keyword.generator.asterisk +// ^^^^ meta.function entity.name.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return function* play(arg) {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^^^^^^^^ meta.function +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function keyword.generator.asterisk +// ^^^^ meta.function entity.name.function +// ^ meta.function punctuation.definition.parameters.begin +// ^^^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return async function play() {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^^^^^^^^^^ meta.function +// ^^^^^ meta.function storage.type +// ^^^^^^^^ meta.function storage.type.function +// ^^^^ meta.function entity.name.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return async function play(arg) {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.function +// ^^^^^ meta.function storage.type +// ^^^^^^^^ meta.function storage.type.function +// ^^^^ meta.function entity.name.function +// ^ meta.function punctuation.definition.parameters.begin +// ^^^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return async function* play() {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^^^^^^^^^^^ meta.function +// ^^^^^ meta.function storage.type +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function keyword.generator.asterisk +// ^^^^ meta.function entity.name.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +return async function* play(arg) {} +//^^^^ keyword.control.flow +//<- source.js +// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function +// ^^^^^ meta.function storage.type +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function keyword.generator.asterisk +// ^^^^ meta.function entity.name.function +// ^ meta.function punctuation.definition.parameters.begin +// ^^^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +yield genfunc; +//^^^ keyword.control.flow +//<- source.js +// ^^^^^^^ variable.other.readwrite +// ^ punctuation.terminator.statement +yield* genfunc; +//^^^ keyword.control.flow +//<- source.js +// ^ keyword.generator.asterisk +// ^^^^^^^ variable.other.readwrite +// ^ punctuation.terminator.statement + + +/** + * Not matched as function definitions + */ + +Sound[play] = function(){} +//^^^ variable.other.object variable.other.object +//<- source.js +// ^ meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.square meta.brace.square.end +// ^ keyword.operator.assignment +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +Sound.prototype.[play] = function(){} +//^^^ meta.prototype.access entity.name.class +//<- source.js +// ^ meta.prototype.access keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.access variable.language.prototype +// ^ keyword.operator.accessor +// ^ meta.group.braces.square meta.brace.square.begin +// ^^^^ meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.square meta.brace.square.end +// ^ keyword.operator.assignment +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + + +A = function() {} +//^^^^^^^^^^^^ meta.function +//^ meta.function keyword.operator.assignment +//<- source.js +//<- meta.function entity.name.function +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +B = function(z) {} +//^^^^^^^^^^^^^ meta.function +//^ meta.function keyword.operator.assignment +//<- source.js +//<- meta.function entity.name.function +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +C = function c() {} +//^^^^^^^^^^^^^^ meta.function +//^ meta.function keyword.operator.assignment +//<- source.js +//<- meta.function entity.name.function +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function entity.name.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +D = function d(z) {} +//^^^^^^^^^^^^^^^ meta.function +//^ meta.function keyword.operator.assignment +//<- source.js +//<- meta.function entity.name.function +// ^^^^^^^^ meta.function storage.type.function +// ^ meta.function entity.name.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +E = () => {} +//^^^^^^^ meta.function.arrow +//^ meta.function.arrow keyword.operator.assignment +//<- source.js +//<- meta.function.arrow entity.name.function +// ^ meta.function.arrow punctuation.definition.parameters.begin +// ^ meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +F = (z) => {} +//^^^^^^^^ meta.function.arrow +//^ meta.function.arrow keyword.operator.assignment +//<- source.js +//<- meta.function.arrow entity.name.function +// ^ meta.function.arrow punctuation.definition.parameters.begin +// ^ meta.function.arrow variable.parameter.function +// ^ meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +G = z => {} +//^^^^^^ meta.function.arrow +//^ meta.function.arrow keyword.operator.assignment +//<- source.js +//<- meta.function.arrow entity.name.function +// ^ meta.function.arrow variable.parameter.function +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +function() {} +//^^^^^^ meta.function storage.type.function +//<- source.js +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +function(z) {} +//^^^^^^ meta.function storage.type.function +//<- source.js +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +function H() {} +//^^^^^^^^^^ meta.function +//^^^^^^ meta.function storage.type.function +//<- source.js +// ^ meta.function entity.name.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +function I(z) {} +//^^^^^^^^^^^ meta.function +//^^^^^^ meta.function storage.type.function +//<- source.js +// ^ meta.function entity.name.function +// ^ meta.function punctuation.definition.parameters.begin +// ^ meta.function variable.parameter.function +// ^ meta.function punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +() => {} +//^^^ meta.function.arrow +//<- source.js +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +(zzz) => {} +//^^^^^^ meta.function.arrow +//^ meta.function.arrow variable.parameter.function +//<- source.js +//<- meta.function.arrow punctuation.definition.parameters.begin +// ^ meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +JJJ.prototype.jjj = () => {} +//^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow +//^ meta.prototype.function.arrow entity.name.class +//<- source.js +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^ meta.prototype.function.arrow entity.name.function +// ^ meta.prototype.function.arrow keyword.operator.assignment +// ^ meta.prototype.function.arrow punctuation.definition.parameters.begin +// ^ meta.prototype.function.arrow punctuation.definition.parameters.end +// ^^ meta.prototype.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +KKK.prototype.kkk = (z) => {} +//^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow +//^ meta.prototype.function.arrow entity.name.class +//<- source.js +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^ meta.prototype.function.arrow entity.name.function +// ^ meta.prototype.function.arrow keyword.operator.assignment +// ^ meta.prototype.function.arrow punctuation.definition.parameters.begin +// ^ meta.prototype.function.arrow variable.parameter.function +// ^ meta.prototype.function.arrow punctuation.definition.parameters.end +// ^^ meta.prototype.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +LLL.prototype.lll = z => {} +//^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow +//^ meta.prototype.function.arrow entity.name.class +//<- source.js +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype +// ^ meta.prototype.function.arrow keyword.operator.accessor +// ^^^ meta.prototype.function.arrow entity.name.function +// ^ meta.prototype.function.arrow keyword.operator.assignment +// ^ meta.prototype.function.arrow variable.parameter.function +// ^^ meta.prototype.function.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +MMM.prototype.mmm = function() {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype +//^ meta.function.prototype entity.name.class +//<- source.js +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^^^^^^ meta.function.prototype variable.language.prototype +// ^ meta.function.prototype keyword.operator.accessor +// ^^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype keyword.operator.assignment +// ^^^^^^^^ meta.function.prototype storage.type.function +// ^ meta.function.prototype punctuation.definition.parameters.begin +// ^ meta.function.prototype punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +NNN.prototype.nnn = function(z) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype +//^ meta.function.prototype entity.name.class +//<- source.js +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^^^^^^ meta.function.prototype variable.language.prototype +// ^ meta.function.prototype keyword.operator.accessor +// ^^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype keyword.operator.assignment +// ^^^^^^^^ meta.function.prototype storage.type.function +// ^ meta.function.prototype punctuation.definition.parameters.begin +// ^ meta.function.prototype variable.parameter.function +// ^ meta.function.prototype punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +OOO.prototype.ooo = function oo() {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype +//^ meta.function.prototype entity.name.class +//<- source.js +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^^^^^^ meta.function.prototype variable.language.prototype +// ^ meta.function.prototype keyword.operator.accessor +// ^^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype keyword.operator.assignment +// ^^^^^^^^ meta.function.prototype storage.type.function +// ^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype punctuation.definition.parameters.begin +// ^ meta.function.prototype punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +PPP.prototype.ppp = function pp(z) {} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype +//^ meta.function.prototype entity.name.class +//<- source.js +// ^ meta.function.prototype keyword.operator.accessor +// ^^^^^^^^^ meta.function.prototype variable.language.prototype +// ^ meta.function.prototype keyword.operator.accessor +// ^^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype keyword.operator.assignment +// ^^^^^^^^ meta.function.prototype storage.type.function +// ^^ meta.function.prototype entity.name.function +// ^ meta.function.prototype punctuation.definition.parameters.begin +// ^ meta.function.prototype variable.parameter.function +// ^ meta.function.prototype punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +QQQ.qqq = () => {} +//^^^^^^^^^^^^^ meta.function.static.arrow +//^ meta.function.static.arrow entity.name.class +//<- source.js +// ^ meta.function.static.arrow keyword.operator.accessor +// ^^^ meta.function.static.arrow entity.name.function +// ^ meta.function.static.arrow keyword.operator.assignment +// ^ meta.function.static.arrow punctuation.definition.parameters.begin +// ^ meta.function.static.arrow punctuation.definition.parameters.end +// ^^ meta.function.static.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +RRR.rrr = (z) => {} +//^^^^^^^^^^^^^^ meta.function.static.arrow +//^ meta.function.static.arrow entity.name.class +//<- source.js +// ^ meta.function.static.arrow keyword.operator.accessor +// ^^^ meta.function.static.arrow entity.name.function +// ^ meta.function.static.arrow keyword.operator.assignment +// ^ meta.function.static.arrow punctuation.definition.parameters.begin +// ^ meta.function.static.arrow variable.parameter.function +// ^ meta.function.static.arrow punctuation.definition.parameters.end +// ^^ meta.function.static.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +SSS.sss = z => {} +//^^^^^^^^^^^^ meta.function.static.arrow +//^ meta.function.static.arrow entity.name.class +//<- source.js +// ^ meta.function.static.arrow keyword.operator.accessor +// ^^^ meta.function.static.arrow entity.name.function +// ^ meta.function.static.arrow keyword.operator.assignment +// ^ meta.function.static.arrow variable.parameter.function +// ^^ meta.function.static.arrow storage.type.function.arrow +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +TTT.ttt = function() {} +//^^^^^^^^^^^^^^^^^^ meta.function.static +//^ meta.function.static entity.name.class +//<- source.js +// ^ meta.function.static keyword.operator.accessor +// ^^^ meta.function.static entity.name.function +// ^ meta.function.static keyword.operator.assignment +// ^^^^^^^^ meta.function.static storage.type.function +// ^ meta.function.static punctuation.definition.parameters.begin +// ^ meta.function.static punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +UUU.uuu = function(z) {} +//^^^^^^^^^^^^^^^^^^^ meta.function.static +//^ meta.function.static entity.name.class +//<- source.js +// ^ meta.function.static keyword.operator.accessor +// ^^^ meta.function.static entity.name.function +// ^ meta.function.static keyword.operator.assignment +// ^^^^^^^^ meta.function.static storage.type.function +// ^ meta.function.static punctuation.definition.parameters.begin +// ^ meta.function.static variable.parameter.function +// ^ meta.function.static punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +VVV.vvv = function vv() {} +//^^^^^^^^^^^^^^^^^^^^^ meta.function.static +//^ meta.function.static entity.name.class +//<- source.js +// ^ meta.function.static keyword.operator.accessor +// ^^^ meta.function.static entity.name.function +// ^ meta.function.static keyword.operator.assignment +// ^^^^^^^^ meta.function.static storage.type.function +// ^^ meta.function.static entity.name.function +// ^ meta.function.static punctuation.definition.parameters.begin +// ^ meta.function.static punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + +WWW.www = function ww(z) {} +//^^^^^^^^^^^^^^^^^^^^^^ meta.function.static +//^ meta.function.static entity.name.class +//<- source.js +// ^ meta.function.static keyword.operator.accessor +// ^^^ meta.function.static entity.name.function +// ^ meta.function.static keyword.operator.assignment +// ^^^^^^^^ meta.function.static storage.type.function +// ^^ meta.function.static entity.name.function +// ^ meta.function.static punctuation.definition.parameters.begin +// ^ meta.function.static variable.parameter.function +// ^ meta.function.static punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end + + +class X extends XX {} +//^^^^^^^^^^^^^^^^^^^ meta.class +//^^^ meta.class storage.type.class +// ^ meta.class entity.name.class +// ^^^^^^^^^^^ meta.class meta.class.extends +// ^^^^^^^ meta.class meta.class.extends storage.type.extends +// ^^ meta.class meta.class.extends variable.other.constant +// ^ meta.class meta.brace.curly.begin +// ^ meta.class meta.brace.curly.end +class Y {} +//^^^^^^^^ meta.class +//^^^ meta.class storage.type.class +// ^ meta.class entity.name.class +// ^ meta.class meta.brace.curly.begin +// ^ meta.class meta.brace.curly.end + + +var node = Relay.QL`node(123) {${Relay.QL`User {address {${fragment}, }, } `} }`; +//^ storage.type +//<- source.js +// ^^^^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^^^^^ meta.property.class variable.other.class +// ^ meta.property.class keyword.operator.accessor +// ^^ meta.property.class variable.other.property.static +// ^^^^^^^^^^^^ string.interpolated +// ^ string.interpolated keyword.other.template.begin +// ^^ keyword.other.substitution.begin +// ^^^^^ meta.property.class variable.other.class +// ^ meta.property.class keyword.operator.accessor +// ^^ meta.property.class variable.other.property.static +// ^^^^^^^^^^^^^^^^ string.interpolated +// ^ string.interpolated keyword.other.template.begin +// ^^ keyword.other.substitution.begin +// ^^^^^^^^ variable.other.readwrite +// ^ keyword.other.substitution.end +// ^^^^^^^^ string.interpolated +// ^ string.interpolated keyword.other.template.end +// ^ keyword.other.substitution.end +// ^^^ string.interpolated +// ^ string.interpolated keyword.other.template.end +// ^ punctuation.terminator.statement diff --git a/Packages/JSX/test/syntax_test_jsx_OLD.js b/Packages/JSX/test/syntax_test_jsx_OLD.js new file mode 100644 index 0000000..552de44 --- /dev/null +++ b/Packages/JSX/test/syntax_test_jsx_OLD.js @@ -0,0 +1,767 @@ +// SYNTAX TEST "Packages/babel-sublime/JavaScript (Babel).tmLanguage" + +
+//^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^ meta.jsx comment.block +// ^^ meta.jsx comment.block punctuation.definition.comment.begin +// ^^ meta.jsx comment.block punctuation.definition.comment.end +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^^^^^^^^ meta.jsx comment.block +// ^^ meta.jsx comment.block punctuation.definition.comment.begin +// ^^ meta.jsx comment.block punctuation.definition.comment.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^ meta.jsx comment.block +// ^^ meta.jsx comment.block punctuation.definition.comment.begin +// ^^ meta.jsx comment.block punctuation.definition.comment.end +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^^^^^^^^ meta.jsx comment.block +// ^^ meta.jsx comment.block punctuation.definition.comment.begin +// ^^ meta.jsx comment.block punctuation.definition.comment.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression constant.numeric +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression constant.numeric +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression constant.numeric +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
this.setState({})} /> +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^^^ meta.jsx meta.embedded.expression meta.function.arrow +// ^ meta.jsx meta.embedded.expression meta.function.arrow punctuation.definition.parameters.begin +// ^ meta.jsx meta.embedded.expression meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.jsx meta.embedded.expression meta.function.arrow storage.type.function.arrow +// ^^^^ meta.jsx meta.embedded.expression variable.language.this +// ^ meta.jsx meta.embedded.expression keyword.operator.accessor +// ^^^^^^^^ meta.jsx meta.embedded.expression meta.function-call.method.with-arguments variable.function +// ^ meta.jsx meta.embedded.expression meta.group.braces.round meta.brace.round.begin +// ^ meta.jsx meta.embedded.expression meta.group.braces.round meta.brace.curly.begin +// ^ meta.jsx meta.embedded.expression meta.group.braces.round meta.brace.curly.end +// ^ meta.jsx meta.embedded.expression meta.group.braces.round meta.brace.round.end +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression constant.numeric +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression constant.numeric +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression constant.numeric +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^^ meta.jsx string.quoted +//^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression constant.numeric +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^^^^^^^^ meta.jsx comment.block +// ^^ meta.jsx comment.block punctuation.definition.comment.begin +// ^^ meta.jsx comment.block punctuation.definition.comment.end +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^ meta.jsx comment.block +// ^^ meta.jsx comment.block punctuation.definition.comment.begin +// ^^ meta.jsx comment.block punctuation.definition.comment.end +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^^^^^^^^ meta.jsx comment.block +// ^^ meta.jsx comment.block punctuation.definition.comment.begin +// ^^ meta.jsx comment.block punctuation.definition.comment.end +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^ meta.jsx comment.block +// ^^ meta.jsx comment.block punctuation.definition.comment.begin +// ^^ meta.jsx comment.block punctuation.definition.comment.end +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + + +// tight greater-/less-than operations. + +for (var i=1; i +//^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^ meta.jsx entity.other.attribute-name +// ^^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end +
+//^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end +
+//^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx keyword.operator.assignment +// ^^ meta.jsx meta.tag punctuation.definition.tag.end +
+//^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^ meta.jsx meta.tag punctuation.definition.tag.end +
+//^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^ meta.jsx meta.tag punctuation.definition.tag.end +
+//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end +
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.end +
+//^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^^^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +// comments between attributes, +// namespaced components, and +// non-alpha chars in tag/attribute names + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^^^^^ meta.jsx comment.block +// ^^ meta.jsx comment.block punctuation.definition.comment.begin +// ^^ meta.jsx comment.block punctuation.definition.comment.end +// ^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^^ meta.jsx meta.embedded.expression variable.language.this +// ^ meta.jsx meta.embedded.expression keyword.operator.accessor +// ^^^^^^^ meta.jsx meta.embedded.expression meta.property.object variable.other.property +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +//^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.tag entity.name.tag +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +//^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^^^^^^^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end +
+//^^^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end + + +/** + * These have always work + */ +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end + {'it\'s with text inside'} +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin +// ^^ meta.jsx meta.embedded.expression string.quoted constant.character.escape +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +
+//^^^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
{'it\'s with text inside'}
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin +// ^^ meta.jsx meta.embedded.expression string.quoted constant.character.escape +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end + {'it\'s with text inside'} +//^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin +// ^^ meta.jsx meta.embedded.expression string.quoted constant.character.escape +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +
+//^^^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
{'it\'s with text inside'}
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin +// ^^ meta.jsx meta.embedded.expression string.quoted constant.character.escape +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end +
+//^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end + {"it's with text inside"} +//^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +
+//^^^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
{"it's with text inside"}
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end + {"it's with text inside"} +//^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin +// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +
+//^^^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end + + + +/** + * Fixed + */ +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end + it's with text inside +
+//^^^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
it's with text inside
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end + it's with text inside +
+//^^^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
it's with text inside
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end +
+//^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end + it's with text inside +
+//^^^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
it's with text inside
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end +
+//^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end + it's with text inside +
+//^^^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
it's with text inside
+//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx +//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
it's with text inside
+//^ meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
it's with text inside
+//^ meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end diff --git a/Packages/JSX/test/syntax_test_jsx_invalid_OLD.js b/Packages/JSX/test/syntax_test_jsx_invalid_OLD.js new file mode 100644 index 0000000..47a719b --- /dev/null +++ b/Packages/JSX/test/syntax_test_jsx_invalid_OLD.js @@ -0,0 +1,231 @@ +// SYNTAX TEST "Packages/babel-sublime/JavaScript (Babel).tmLanguage" + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression constant.numeric +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression constant.numeric +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^ meta.jsx entity.other.attribute-name +// ^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^ meta.jsx entity.other.attribute-name +// ^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.jsx meta.embedded.expression constant.numeric +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx keyword.operator.assignment +// ^^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx keyword.operator.assignment +// ^^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx entity.other.attribute-name +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^ meta.jsx keyword.operator.assignment +// ^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx keyword.operator.assignment +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^^^^^ meta.jsx string.quoted +//^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +< > +//<- meta.jsx invalid.illegal.tag.incomplete + +
+//^ meta.jsx meta.tag entity.name.tag +//<- meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^^^^ meta.jsx entity.other.attribute-name +// ^^^^^^^^^ meta.jsx string.quoted +// ^ meta.jsx string.quoted punctuation.definition.string.begin +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^^^^ meta.jsx entity.other.attribute-name +// ^^ meta.jsx meta.tag punctuation.definition.tag.end + +
+//^^^^ keyword.operator.module +//<- source.js +// ^^^^^^^ keyword.control.loop +// ^^^^^^^^^^^^^^^^^^^^ meta.jsx +// ^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^ meta.jsx meta.tag entity.name.tag +// ^^ meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end + +export default React.createClass({ +//^^^^ keyword.operator.module +//<- source.js +// ^^^^^^^ keyword.control.loop +// ^^^^^ meta.function-call.static.with-arguments variable.other.class +// ^ meta.function-call.static.with-arguments keyword.operator.accessor +// ^^^^^^^^^^^ meta.function-call.static.with-arguments variable.function +// ^ meta.group.braces.round meta.brace.round.begin +// ^ meta.brace.curly.begin + + mixins: [InputsMixin], +//^^^^^^ constant.other.object.key string.unquoted.label +// ^ constant.other.object.key punctuation.separator.key-value +// ^ meta.group.braces.square meta.brace.square.begin +// ^^^^^^^^^^^ meta.group.braces.square variable.other.readwrite +// ^ meta.group.braces.square meta.brace.square.end +// ^ meta.delimiter.comma + + submit() { +//^^^^^^ meta.method string.unquoted entity.name.function +// ^ meta.method punctuation.definition.parameters.begin +// ^ meta.method punctuation.definition.parameters.end +// ^ meta.brace.curly.begin + + var {email, question} = this.state; +// ^^^ storage.type +// ^^^^^^^^^^^^^^^^^ meta.group.braces.curly +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^^^^^ meta.group.braces.curly variable.other.readwrite +// ^ meta.group.braces.curly meta.delimiter.comma +// ^^^^^^^^ meta.group.braces.curly variable.other.readwrite +// ^ meta.group.braces.curly meta.brace.curly.end +// ^ keyword.operator.assignment +// ^^^^ variable.language.this +// ^ keyword.operator.accessor +// ^^^^^ meta.property.object variable.other.property +// ^ punctuation.terminator.statement + request +// ^^^^^^^ variable.other.readwrite + + .post(`${API_BASE}/askform`) +// ^ keyword.operator.accessor +// ^^^^ meta.function-call.method.with-arguments variable.function +// ^ meta.group.braces.round meta.brace.round.begin +// ^ meta.group.braces.round string.interpolated keyword.other.template.begin +// ^^ meta.group.braces.round keyword.other.substitution.begin +// ^^^^^^^^ meta.group.braces.round variable.other.constant +// ^ meta.group.braces.round keyword.other.substitution.end +// ^^^^^^^^^ meta.group.braces.round string.interpolated +// ^ meta.group.braces.round string.interpolated keyword.other.template.end +// ^ meta.group.braces.round meta.brace.round.end + .send({email, question}) +// ^ keyword.operator.accessor +// ^^^^ meta.function-call.method.with-arguments variable.function +// ^ meta.group.braces.round meta.brace.round.begin +// ^^^^^^^^^^^^^^^^^ +// ^ meta.brace.curly.begin +// ^^^^^ variable.other.readwrite +// ^ meta.delimiter.comma +// ^^^^^^^^ variable.other.readwrite +// ^ meta.brace.curly.end +// ^ meta.group.braces.round meta.brace.round.end + .end((err, res) => +// ^ keyword.operator.accessor +// ^^^ meta.function-call.method.with-arguments variable.function +// ^ meta.group.braces.round meta.brace.round.begin +// ^^^^^^^^^^^^^ meta.group.braces.round meta.function.arrow +// ^ meta.group.braces.round meta.function.arrow punctuation.definition.parameters.begin +// ^^^ meta.group.braces.round meta.function.arrow variable.parameter.function +// ^ meta.group.braces.round meta.function.arrow punctuation.separator.parameter.function +// ^^^ meta.group.braces.round meta.function.arrow variable.parameter.function +// ^ meta.group.braces.round meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.group.braces.round meta.function.arrow storage.type.function.arrow + this.setState({isValid: !err})); +// ^^^^ meta.group.braces.round variable.language.this +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.round +// ^ meta.group.braces.round keyword.operator.accessor +// ^^^^^^^^ meta.group.braces.round meta.function-call.method.with-arguments variable.function +// ^ meta.group.braces.round meta.group.braces.round meta.brace.round.begin +// ^^^^^^^^^^^^^^^ meta.group.braces.round +// ^ meta.group.braces.round meta.brace.curly.begin +// ^^^^^^^ meta.group.braces.round constant.other.object.key string.unquoted.label +// ^ meta.group.braces.round constant.other.object.key punctuation.separator.key-value +// ^ meta.group.braces.round keyword.operator.logical +// ^^^ meta.group.braces.round variable.other.readwrite +// ^ meta.group.braces.round meta.brace.curly.end +// ^^ meta.group.braces.round meta.brace.round.end +// ^ meta.group.braces.round meta.group.braces.round meta.brace.round.end +// ^ punctuation.terminator.statement + }, +//^ meta.brace.curly.end +// ^ meta.delimiter.comma + + + 'key//1': function() {}, +//^^^^^^^^^^^^^^^^^^^^ meta.function.json +//^ meta.function.json string.quoted punctuation.definition.string.begin +// ^^^^^^ meta.function.json string.quoted entity.name.function +// ^ meta.function.json string.quoted punctuation.definition.string.end +// ^ meta.function.json punctuation.separator.key-value +// ^^^^^^^^ meta.function.json storage.type.function +// ^ meta.function.json punctuation.definition.parameters.begin +// ^ meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +// ^ meta.delimiter.comma + + 'key/***/1': function() {}, +//^^^^^^^^^^^^^^^^^^^^^^^ meta.function.json +//^ meta.function.json string.quoted punctuation.definition.string.begin +// ^^^^^^^^^ meta.function.json string.quoted entity.name.function +// ^ meta.function.json string.quoted punctuation.definition.string.end +// ^ meta.function.json punctuation.separator.key-value +// ^^^^^^^^ meta.function.json storage.type.function +// ^ meta.function.json punctuation.definition.parameters.begin +// ^ meta.function.json punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin +// ^ meta.group.braces.curly meta.brace.curly.end +// ^ meta.delimiter.comma + + + render() { +//^^^^^^ meta.method string.unquoted entity.name.function +// ^ meta.method punctuation.definition.parameters.begin +// ^ meta.method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin + var {email} = this.state; +// ^^^ meta.group.braces.curly storage.type +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin +// ^^^^^ meta.group.braces.curly meta.group.braces.curly variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly keyword.operator.assignment +// ^^^^ meta.group.braces.curly variable.language.this +// ^ meta.group.braces.curly keyword.operator.accessor +// ^^^^^ meta.group.braces.curly meta.property.object variable.other.property +// ^ meta.group.braces.curly punctuation.terminator.statement + var list = this.props.secondary.map(pic => )} +// ^^^ meta.group.braces.curly storage.type +// ^^^^ meta.group.braces.curly variable.other.readwrite +// ^ meta.group.braces.curly keyword.operator.assignment +// ^^^^ meta.group.braces.curly variable.language.this +// ^ meta.group.braces.curly keyword.operator.accessor +// ^^^^^ meta.group.braces.curly meta.property.object variable.other.property +// ^ meta.group.braces.curly keyword.operator.accessor +// ^^^^^^^^^ meta.group.braces.curly meta.property.object variable.other.property +// ^ meta.group.braces.curly keyword.operator.accessor +// ^^^ meta.group.braces.curly meta.function-call.method.with-arguments variable.function +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin +// ^^^^^^ meta.group.braces.curly meta.group.braces.round meta.function.arrow +// ^^^ meta.group.braces.curly meta.group.braces.round meta.function.arrow variable.parameter.function +// ^^ meta.group.braces.curly meta.group.braces.round meta.function.arrow storage.type.function.arrow +// ^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.group.braces.round meta.jsx +// ^ meta.group.braces.curly meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.group.braces.curly meta.group.braces.round meta.jsx meta.tag entity.name.tag +// ^^^ meta.group.braces.curly meta.group.braces.round meta.jsx entity.other.attribute-name +// ^ meta.group.braces.curly meta.group.braces.round meta.jsx keyword.operator.assignment +// ^ meta.group.braces.curly meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^ meta.group.braces.curly meta.group.braces.round meta.jsx meta.embedded.expression variable.other.readwrite +// ^ meta.group.braces.curly meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^ meta.group.braces.curly meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.end +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end +// ^ meta.group.braces.curly meta.brace.curly.end + var multilineAttr = +// ^ meta.jsx string.quoted punctuation.definition.string.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end + + return ( +// ^^^^^^ keyword.control.flow +// ^ meta.group.braces.round meta.brace.round.begin +
test
}> +// ^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.group.braces.round meta.jsx meta.tag entity.name.tag +// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^ meta.group.braces.round meta.jsx meta.embedded.expression keyword.operator.spread +// ^^^^ meta.group.braces.round meta.jsx meta.embedded.expression variable.language.this +// ^ meta.group.braces.round meta.jsx meta.embedded.expression keyword.operator.accessor +// ^^^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.property.object variable.other.property +// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^^^^^^^ meta.group.braces.round meta.jsx entity.other.attribute-name +// ^ meta.group.braces.round meta.jsx keyword.operator.assignment +// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^^^^^^^^^^^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx +// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx meta.tag entity.name.tag +// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx meta.tag entity.name.tag +// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx meta.tag punctuation.definition.tag.end +// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.end + +// ^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^ meta.group.braces.round meta.jsx meta.tag entity.name.tag +// ^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^^^ meta.group.braces.round meta.jsx meta.tag entity.name.tag +// ^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.end + + {list} +// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^^ meta.group.braces.round meta.jsx meta.embedded.expression variable.other.readwrite +// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.end + {[in an array]} +// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.brace.square.begin +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx +// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx meta.tag entity.name.tag +// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx meta.tag punctuation.definition.tag.end +// ^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx meta.tag entity.name.tag +// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx meta.tag punctuation.definition.tag.end +// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.brace.square.end +// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.end + + +// ^^^^^^^^ meta.group.braces.round meta.jsx entity.other.attribute-name +// ^^^^^^^ meta.group.braces.round meta.jsx comment.block +// ^^ meta.group.braces.round meta.jsx comment.block punctuation.definition.comment.begin +// ^^ meta.group.braces.round meta.jsx comment.block punctuation.definition.comment.end +// ^^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.end + +
+ ); + } +}); + + +export class Counter extends React.Component { +//^^^^ keyword.operator.module +//<- source.js +// ^^^^^ storage.type.class +// ^^^^^^^ entity.name.class +// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.extends +// ^^^^^^^ meta.class.extends storage.type.extends +// ^^^^^ meta.class.extends meta.property.class variable.other.class +// ^ meta.class.extends meta.property.class keyword.operator.accessor +// ^^^^^^^^^ meta.class.extends meta.property.class variable.other.property.static +// ^ meta.brace.curly.begin + static propTypes = { initialCount: React.PropTypes.number }; +//^^^^^^ storage.modifier +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.property +// ^^^^^^^^^ meta.class.property variable.other.property +// ^ meta.class.property keyword.operator.assignment +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.property meta.group.braces.curly +// ^ meta.class.property meta.group.braces.curly meta.brace.curly.begin +// ^^^^^^^^^^^^ meta.class.property meta.group.braces.curly constant.other.object.key string.unquoted.label +// ^ meta.class.property meta.group.braces.curly constant.other.object.key punctuation.separator.key-value +// ^^^^^ meta.class.property meta.group.braces.curly meta.property.class variable.other.class +// ^ meta.class.property meta.group.braces.curly meta.property.class keyword.operator.accessor +// ^^^^^^^^^ meta.class.property meta.group.braces.curly meta.property.class variable.other.property.static +// ^ meta.class.property meta.group.braces.curly keyword.operator.accessor +// ^^^^^^ meta.class.property meta.group.braces.curly meta.property.object variable.other.property +// ^ meta.class.property meta.group.braces.curly meta.brace.curly.end + static defaultProps = { initialCount: 0 }; +//^^^^^^ storage.modifier +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.property +// ^^^^^^^^^^^^ meta.class.property variable.other.property +// ^ meta.class.property keyword.operator.assignment +// ^^^^^^^^^^^^^^^^^^^ meta.class.property meta.group.braces.curly +// ^ meta.class.property meta.group.braces.curly meta.brace.curly.begin +// ^^^^^^^^^^^^ meta.class.property meta.group.braces.curly constant.other.object.key string.unquoted.label +// ^ meta.class.property meta.group.braces.curly constant.other.object.key punctuation.separator.key-value +// ^ meta.class.property meta.group.braces.curly constant.numeric +// ^ meta.class.property meta.group.braces.curly meta.brace.curly.end + static childContextTypes = () => { +//^^^^^^ storage.modifier +// ^^^^^^^^^^^^^^^^^ meta.class.property variable.other.property +// ^ meta.class.property keyword.operator.assignment +// ^^^^^ meta.class.property meta.function.arrow +// ^ meta.class.property meta.function.arrow punctuation.definition.parameters.begin +// ^ meta.class.property meta.function.arrow punctuation.definition.parameters.end +// ^^ meta.class.property meta.function.arrow storage.type.function.arrow +// ^ meta.class.property meta.group.braces.curly meta.brace.curly.begin + return { +// ^^^^^^ meta.class.property meta.group.braces.curly keyword.control.flow +// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin + + app: React.PropTypes.instanceOf(App).isRequired +// ^^^ meta.class.property meta.group.braces.curly meta.group.braces.curly constant.other.object.key string.unquoted.label +// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly constant.other.object.key punctuation.separator.key-value +// ^^^^^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.property.class variable.other.class +// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.property.class keyword.operator.accessor +// ^^^^^^^^^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.property.class variable.other.property.static +// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly keyword.operator.accessor +// ^^^^^^^^^^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.function-call.method.with-arguments variable.function +// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.group.braces.round meta.brace.round.begin +// ^^^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.group.braces.round variable.other.readwrite +// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.group.braces.round meta.brace.round.end +// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly keyword.operator.accessor +// ^^^^^^^^^^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.property.object variable.other.property + } +// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end + }; +//^ meta.class.property meta.group.braces.curly meta.brace.curly.end + getChildContext = makeGetChildContext(); +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.property +//^^^^^^^^^^^^^^^ meta.class.property variable.other.property +// ^ meta.class.property keyword.operator.assignment +// ^^^^^^^^^^^^^^^^^^^ meta.class.property meta.function-call.without-arguments variable.function +// ^^ meta.class.property meta.function-call.without-arguments meta.group.braces.round.function.arguments + state = { count: this.props.initialCount }; +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.property +//^^^^^ meta.class.property variable.other.property +// ^ meta.class.property keyword.operator.assignment +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.property meta.group.braces.curly +// ^ meta.class.property meta.group.braces.curly meta.brace.curly.begin +// ^^^^^ meta.class.property meta.group.braces.curly constant.other.object.key string.unquoted.label +// ^ meta.class.property meta.group.braces.curly constant.other.object.key punctuation.separator.key-value +// ^^^^ meta.class.property meta.group.braces.curly variable.language.this +// ^ meta.class.property meta.group.braces.curly keyword.operator.accessor +// ^^^^^ meta.class.property meta.group.braces.curly meta.property.object variable.other.property +// ^ meta.class.property meta.group.braces.curly keyword.operator.accessor +// ^^^^^^^^^^^^ meta.class.property meta.group.braces.curly meta.property.object variable.other.property +// ^ meta.class.property meta.group.braces.curly meta.brace.curly.end + tick() { +//^^^^ meta.class-method string.unquoted entity.name.function +// ^ meta.class-method punctuation.definition.parameters.begin +// ^ meta.class-method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin + this.setState({ count: this.state.count + 1 }); +// ^^^^ meta.group.braces.curly variable.language.this +// ^ meta.group.braces.curly keyword.operator.accessor +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly +// ^^^^^^^^ meta.group.braces.curly meta.function-call.method.with-arguments variable.function +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly +// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly meta.brace.curly.begin +// ^^^^^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly constant.other.object.key string.unquoted.label +// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly constant.other.object.key punctuation.separator.key-value +// ^^^^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly variable.language.this +// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly keyword.operator.accessor +// ^^^^^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly meta.property.object variable.other.property +// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly keyword.operator.accessor +// ^^^^^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly meta.property.object variable.other.property +// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly keyword.operator.arithmetic +// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly constant.numeric +// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly meta.brace.curly.end +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end +// ^ meta.group.braces.curly punctuation.terminator.statement + } +//^ meta.group.braces.curly meta.brace.curly.end + render() { +//^^^^^^ meta.class-method string.unquoted entity.name.function +// ^ meta.class-method punctuation.definition.parameters.begin +// ^ meta.class-method punctuation.definition.parameters.end +// ^ meta.group.braces.curly meta.brace.curly.begin + return ( +// ^^^^^^ meta.group.braces.curly keyword.control.flow +// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin +
+// ^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^^^^^^^ meta.jsx entity.other.attribute-name +// ^ meta.jsx keyword.operator.assignment +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^^ meta.jsx meta.embedded.expression variable.language.this +// ^ meta.jsx meta.embedded.expression keyword.operator.accessor +// ^^^^ meta.jsx meta.embedded.expression meta.property.object variable.other.property +// ^ meta.jsx meta.embedded.expression keyword.operator.accessor +// ^^^^ meta.jsx meta.embedded.expression meta.function-call.method.with-arguments variable.function +// ^ meta.jsx meta.embedded.expression meta.group.braces.round meta.brace.round.begin +// ^^^^ meta.jsx meta.embedded.expression meta.group.braces.round variable.language.this +// ^ meta.jsx meta.embedded.expression meta.group.braces.round meta.brace.round.end +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +// ^ meta.jsx meta.tag punctuation.definition.tag.end + Clicks: {this.state.count} +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin +// ^^^^ meta.jsx meta.embedded.expression variable.language.this +// ^ meta.jsx meta.embedded.expression keyword.operator.accessor +// ^^^^^ meta.jsx meta.embedded.expression meta.property.object variable.other.property +// ^ meta.jsx meta.embedded.expression keyword.operator.accessor +// ^^^^^ meta.jsx meta.embedded.expression meta.property.object variable.other.property +// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end +
+// ^^ meta.jsx meta.tag punctuation.definition.tag.begin +// ^^^ meta.jsx meta.tag entity.name.tag +// ^ meta.jsx meta.tag punctuation.definition.tag.end + ); +// ^ meta.brace.round.end +// ^ meta.group.braces.curly punctuation.terminator.statement + } +//^ meta.group.braces.curly meta.brace.curly.end +} +//<- meta.class meta.brace.curly.end diff --git a/Packages/JSX/test/syntax_test_relational_OLD.js b/Packages/JSX/test/syntax_test_relational_OLD.js new file mode 100644 index 0000000..287954a --- /dev/null +++ b/Packages/JSX/test/syntax_test_relational_OLD.js @@ -0,0 +1,289 @@ +// SYNTAX TEST "Packages/babel-sublime/JavaScript (Babel).tmLanguage" + +var a = b +//^ storage.type +//<- source.js +// ^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^ variable.other.readwrite +// ^ keyword.operator.relational +// ^^^ variable.other.readwrite +// ^^^^^^^^^^^ comment.block +// ^^ comment.block punctuation.definition.comment.begin +// ^^ comment.block punctuation.definition.comment.end +// ^^^^^ string.regexp +// ^ string.regexp punctuation.definition.string.begin + +/ +//<- string.regexp punctuation.definition.string.end + +var a = b +//^ storage.type +//<- source.js +// ^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^ variable.other.readwrite +// ^ keyword.operator.relational +// ^^^ variable.other.readwrite +// ^ keyword.operator.arithmetic +// ^ keyword.operator.relational + +var a = b +//^ storage.type +//<- source.js +// ^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^ variable.other.readwrite +// ^ keyword.operator.relational +// ^^^ variable.other.readwrite +// ^ keyword.operator.arithmetic +// ^ keyword.operator.relational + +var a = b +//^ storage.type +//<- source.js +// ^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^ variable.other.readwrite +// ^ keyword.operator.relational +// ^^^ variable.other.readwrite +// ^ keyword.operator.arithmetic +// ^^^ variable.other.readwrite +// ^ keyword.operator.arithmetic +// ^ keyword.operator.relational + +var a = b +//^ storage.type +//<- source.js +// ^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^ variable.other.readwrite +// ^ keyword.operator.relational +// ^^^ variable.other.readwrite +// ^ keyword.operator.arithmetic +// ^^^ variable.other.readwrite +// ^ keyword.operator.arithmetic +// ^ keyword.operator.relational + +var a = b +//^ storage.type +//<- source.js +// ^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^ variable.other.readwrite +// ^ keyword.operator.relational +// ^^^^^^^ variable.other.readwrite +// ^ keyword.operator.arithmetic +// ^ keyword.operator.relational + +var a = b +//^ storage.type +//<- source.js +// ^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^ variable.other.readwrite +// ^ keyword.operator.relational +// ^^^ variable.other.readwrite +// ^ keyword.operator.arithmetic +// ^^^ variable.other.readwrite +// ^ keyword.operator.arithmetic +// ^ keyword.operator.relational + +var a = b +//^ storage.type +//<- source.js +// ^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^ variable.other.readwrite +// ^ keyword.operator.relational +// ^^^ variable.other.object variable.other.object +// ^ keyword.operator.accessor +// ^^^ meta.property.object variable.other.property +// ^ keyword.operator.arithmetic +// ^ keyword.operator.relational + +var a = b +//^ storage.type +//<- source.js +// ^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^ variable.other.readwrite +// ^ keyword.operator.relational +// ^^^ variable.other.object variable.other.object +// ^ keyword.operator.accessor +// ^^^ meta.property.object variable.other.property +// ^^^^^^^^^^^ comment.block +// ^^ comment.block punctuation.definition.comment.begin +// ^^ comment.block punctuation.definition.comment.end +// ^^^^^ string.regexp +// ^ string.regexp punctuation.definition.string.begin + +/ +//<- string.regexp punctuation.definition.string.end + +var a = b +//^ storage.type +//<- source.js +// ^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^ variable.other.readwrite +// ^ keyword.operator.relational +// ^^^ variable.other.readwrite +// ^ keyword.operator.arithmetic +// ^^^^^ string.regexp +// ^ string.regexp punctuation.definition.string.begin + +/ +//<- string.regexp punctuation.definition.string.end + +var a = b +//^ storage.type +//<- source.js +// ^ variable.other.readwrite +// ^ keyword.operator.assignment +// ^ variable.other.readwrite +// ^ keyword.operator.relational +// ^^^ variable.other.object variable.other.object +// ^ keyword.operator.accessor +// ^^^^ string.regexp +// ^ string.regexp punctuation.definition.string.begin diff --git a/Packages/JSX/test/syntax_test_styles.js b/Packages/JSX/test/syntax_test_styles.js new file mode 100644 index 0000000..53728aa --- /dev/null +++ b/Packages/JSX/test/syntax_test_styles.js @@ -0,0 +1,96 @@ +// SYNTAX TEST "JavaScript (Babel).tmLanguage" + +styled.h1`color: #ffcc00;` +//^^^^^^^^^^^^^^^^^^^^^^^^ meta.styled-components +//^^^^ variable.other.object +// ^ punctuation.accessor +// ^^ variable.function.tagged-template +// ^ punctuation.definition.string.template.begin +// ^^^^^^^^^^^^^^^ source.css.embedded +// ^^^^^^^^^^^^^^^ meta.property-list.css +// ^ punctuation.definition.string.template.end + + styled.h1`` +// ^^^^^^^^^^^ meta.styled-components +//^^ -meta.styled-components +// ^^ -meta.styled-components + +styled(Foo)`color: #ffcc00;` +//^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.styled-components +//^^^^^^^^^ meta.function-call.with-arguments +// ^^^^^^^^^^^^^^^^^ -meta.function-call.with-arguments +//^^^^ variable.function +// ^^^^^ meta.group +// ^ punctuation.definition.group.begin +// ^^^ variable.other.readwrite +// ^ punctuation.definition.group.end +// ^ punctuation.definition.string.template.begin +// ^^^^^^^^^^^^^^^ source.css.embedded +// ^^^^^^^^^^^^^^^ meta.property-list.css +// ^ punctuation.definition.string.template.end + + styled(Foo)`` +// ^^^^^^^^^^^^^ meta.styled-components +//^^ -meta.styled-components +// ^^ -meta.styled-components + +styled(Foo.bar())`color: #ffcc00;` +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.styled-components +//^^^^^^^^^^^^^^^ meta.function-call.with-arguments +// ^^^^^^^^^^^^^^^^^ -meta.function-call.with-arguments +//^^^^ variable.function +// ^^^^^^^^^^^ meta.group +// ^ punctuation.definition.group.begin +// ^^^ variable.other.class +// ^ keyword.operator.accessor +// ^^^ variable.function +// ^ punctuation.definition.group.end +// ^ punctuation.definition.string.template.begin +// ^^^^^^^^^^^^^^^ source.css.embedded +// ^^^^^^^^^^^^^^^ meta.property-list.css +// ^ punctuation.definition.string.template.end + + styled(Foo.bar())`` +// ^^^^^^^^^^^^^^^^^^^ meta.styled-components +//^^ -meta.styled-components +// ^^ -meta.styled-components + +styled('div')`color: #ffcc00;` +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.styled-components +//^^^^^^^^^^^ meta.function-call.with-arguments +// ^^^^^^^^^^^^^^^^^ -meta.function-call.with-arguments +//^^^^ variable.function +// ^^^^^^^ meta.group +// ^ punctuation.definition.group.begin +// ^^^^^ string.quoted +// ^ punctuation.definition.group.end +// ^ punctuation.definition.string.template.begin +// ^^^^^^^^^^^^^^^ source.css.embedded +// ^^^^^^^^^^^^^^^ meta.property-list.css +// ^ punctuation.definition.string.template.end + +injectGlobal`color: #ffcc00;` +//^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.styled-components +//^^^^^^^^^ variable.function.tagged-template +// ^ punctuation.definition.string.template.begin +// ^^^^^^^^^^^^^^^ source.css.embedded +// ^^^^^^^^^^^^^^^ meta.property-list.css +// ^ punctuation.definition.string.template.end + + injectGlobal`` +// ^^^^^^^^^^^^^^ meta.styled-components +//^^ -meta.styled-components +// ^^ -meta.styled-components + +keyframes`0%{color: red;} 50%{color: blue;}` +//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.styled-components +//^^^^^^^ variable.function.tagged-template +// ^ punctuation.definition.string.template.begin +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ source.css.embedded +// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.property-list.css +// ^ punctuation.definition.string.template.end + + keyframes`` +// ^^^^^^^^^^^ meta.styled-components +//^^ -meta.styled-components +// ^^ -meta.styled-components From 100798fa0871a539fe98283dc2eefbab9ede9b99 Mon Sep 17 00:00:00 2001 From: Matthias Date: Mon, 13 May 2019 20:22:17 -0700 Subject: [PATCH 2/5] Remove unecessary files, update README Update README with a link to the original repository. Remove: -Tests -Screenshots -Theme files -packson.json -Version update messages --- Packages/JSX/Next.YAML-tmTheme | 854 ----- Packages/JSX/Next.tmTheme | 1868 ---------- Packages/JSX/README.md | 2 + Packages/JSX/messages.json | 8 - Packages/JSX/messages/3.0.0.txt | 4 - Packages/JSX/messages/4.0.0.txt | 4 - Packages/JSX/messages/5.0.0.txt | 11 - Packages/JSX/messages/7.1.0.txt | 28 - Packages/JSX/messages/8.0.0.txt | 14 - Packages/JSX/messages/9.0.0.txt | 8 - Packages/JSX/package.json | 4 - .../compare-jsx-comments-etc@2x.png | Bin 37079 -> 0 bytes .../screenshots/compare-jsx-illegal@2x.png | Bin 30862 -> 0 bytes .../JSX/screenshots/compare-jsx-tight@2x.png | Bin 24980 -> 0 bytes .../screenshots/compare-react-class@2x.png | Bin 57670 -> 0 bytes Packages/JSX/screenshots/oceanic-next.png | Bin 59838 -> 0 bytes Packages/JSX/test/syntax_test_issues_OLD.js | 275 -- Packages/JSX/test/syntax_test_js_babel_OLD.js | 3187 ----------------- Packages/JSX/test/syntax_test_jsx_OLD.js | 767 ---- .../JSX/test/syntax_test_jsx_invalid_OLD.js | 231 -- .../JSX/test/syntax_test_react_class_OLD.js | 485 --- .../JSX/test/syntax_test_relational_OLD.js | 289 -- Packages/JSX/test/syntax_test_styles.js | 96 - 23 files changed, 2 insertions(+), 8133 deletions(-) delete mode 100644 Packages/JSX/Next.YAML-tmTheme delete mode 100644 Packages/JSX/Next.tmTheme delete mode 100644 Packages/JSX/messages.json delete mode 100644 Packages/JSX/messages/3.0.0.txt delete mode 100644 Packages/JSX/messages/4.0.0.txt delete mode 100644 Packages/JSX/messages/5.0.0.txt delete mode 100644 Packages/JSX/messages/7.1.0.txt delete mode 100644 Packages/JSX/messages/8.0.0.txt delete mode 100644 Packages/JSX/messages/9.0.0.txt delete mode 100644 Packages/JSX/package.json delete mode 100644 Packages/JSX/screenshots/compare-jsx-comments-etc@2x.png delete mode 100644 Packages/JSX/screenshots/compare-jsx-illegal@2x.png delete mode 100644 Packages/JSX/screenshots/compare-jsx-tight@2x.png delete mode 100644 Packages/JSX/screenshots/compare-react-class@2x.png delete mode 100644 Packages/JSX/screenshots/oceanic-next.png delete mode 100644 Packages/JSX/test/syntax_test_issues_OLD.js delete mode 100644 Packages/JSX/test/syntax_test_js_babel_OLD.js delete mode 100644 Packages/JSX/test/syntax_test_jsx_OLD.js delete mode 100644 Packages/JSX/test/syntax_test_jsx_invalid_OLD.js delete mode 100644 Packages/JSX/test/syntax_test_react_class_OLD.js delete mode 100644 Packages/JSX/test/syntax_test_relational_OLD.js delete mode 100644 Packages/JSX/test/syntax_test_styles.js diff --git a/Packages/JSX/Next.YAML-tmTheme b/Packages/JSX/Next.YAML-tmTheme deleted file mode 100644 index ded69d2..0000000 --- a/Packages/JSX/Next.YAML-tmTheme +++ /dev/null @@ -1,854 +0,0 @@ -# [PackageDev] target_format: plist, ext: tmTheme -name: Next -uuid: 35279c3b-adad-473e-b960-fee631f4d9a5 - -settings: -- settings: - activeGuide: '#3333FFFF' - background: '#000000' - bracketsBackground: '#FF00AA66' - bracketsOptions: background - caret: '#FF0099' - foreground: '#E6E6E6' - guide: '#33333388' - gutter: '#6600FF33' - invisibles: '#404040' - lineHighlight: '#FF009933' - multiEditHighlight: '#00FF0022' - searchHighlight: '#FF00AA99' - selection: '#00FFFF44' - stackGuide: '#333333CC' - -- name: bracket.curly - scope: bracket.curly - settings: - background: '#FF44AA' - foreground: '#3399FF' - -- name: bracket.square - scope: bracket.square - settings: - background: '#2266CC' - foreground: '#FF8800' - -- name: bracket.round - scope: bracket.round - settings: - background: '#9922FF' - foreground: '#00FF00' - -- name: bracket.quote - scope: bracket.quote - settings: - background: '#00FF00' - -- name: comment - scope: comment - settings: - fontStyle: italic - foreground: '#646464FF' - -- name: Invalid - scope: invalid - settings: - background: '#FF000022' - -- name: constant - scope: constant - settings: - foreground: '#3387CCFF' - -- name: Keyword - scope: keyword - settings: - foreground: '#E28964' - -- name: constant.numeric - scope: constant.numeric - settings: - foreground: '#FFFF66' - -- name: Storage - scope: storage - settings: - foreground: '#99CF50' - -- name: storage.modifier - scope: storage.modifier - settings: - foreground: '#CF5099' - -- name: storage.self - scope: storage.self - settings: - fontStyle: bold - foreground: '#CC0033' - -- name: storage.type - scope: storage.type - settings: - foreground: '#CF9950' - -- name: Support - scope: support - settings: - foreground: '#8A5C8DFF' - -- name: entity.name.function - scope: entity.name.function - settings: - foreground: '#BB00FF' - -- name: keyword control - scope: keyword.control - settings: - foreground: '#FF00FF' - -- name: keyword.control.declaration - scope: keyword.control.declaration - settings: - foreground: '#8888AA' - -- name: keyword.control.module - scope: keyword.control.module - settings: - background: '#FFFF3333' - foreground: '#FFFF33' - options: underline - -- name: keyword.control.flow - scope: keyword.control.flow - settings: - background: '#110300' - fontStyle: bold - foreground: '#FF6600' - -- name: keyword.control.conditional - scope: keyword.control.conditional - settings: - foreground: '#FF00FF' - -- name: keyword.control.trycatch - scope: keyword.control.trycatch - settings: - foreground: '#FF0033' - -- name: keyword.control.loop - scope: keyword.control.loop - settings: - foreground: '#009999' - -- name: keyword.control.switch - scope: keyword.control.switch - settings: - foreground: '#999999' - -- name: keyword operator - scope: keyword.operator - settings: - foreground: '#FF0080' - -- name: Function arg - scope: meta.function.argument, variable.parameter, meta.parens.c - settings: - foreground: '#77FF11' - -- name: '' - scope: punctuation.section.embedded - settings: - background: '#0D0D0D37' - foreground: '#00D3FFFF' - -- name: keyword.other.unit - scope: keyword.other.unit, keyword.unit.css - settings: - foreground: '#80FF00FF' - -- name: invalid.illegal - scope: invalid.illegal - settings: - background: '#562D56BF' - foreground: '#FD5FF1FF' - -- name: string.quoted source - scope: string.quoted source - settings: - foreground: '#DAEFA3' - -- name: string constant - scope: string constant - settings: - foreground: '#CFED81' - -- name: string.regexp - scope: string.regexp - settings: - foreground: '#6FFF17' - -- name: punctuation.definition.string - scope: punctuation.definition.string - settings: - background: '#15151501' - foreground: '#B4FF82' - -- name: string.regexp.special - scope: "string.regexp constant.character.escape, string.regexp source.ruby.embedded, string.regexp string.regexp.arbitrary-repitition" - settings: - foreground: '#00D505' - -- name: string.regexp punctuation keyword - scope: string.regexp punctuation keyword - settings: - foreground: '#C559FF' - -- name: string variable - scope: string variable - settings: - foreground: '#8A9A95' - -- name: support.function - scope: support.function - settings: - foreground: '#FCF352FF' - -- name: meta.tag - scope: meta.tag - settings: - foreground: '#4F9EFFFF' - -- name: meta.tag entity - scope: meta.tag entity - settings: - foreground: '#157EFF' - -- name: HTML/XML tag attribute value - scope: meta.tag string.quoted.double.html - settings: - foreground: '#E07D2C' - -- name: html5 tag - scope: meta.tag.block.any.html.html5 - settings: - foreground: '#E88BFCFF' - -- name: html5 tag entity - scope: meta.tag.block.any.html.html5 entity - settings: - foreground: '#D730FAFF' - -- name: meta.tag.inline - scope: "source entity.name.tag, source entity.other.attribute-name,meta.tag.inline, meta.tag.inline entity" - settings: - foreground: '#87A7E2FF' - -- name: html js tag - scope: source.js.embedded.html entity.name.tag.script.html - settings: - foreground: '#FF3535' - -- name: html js tag braces - scope: source.js.embedded.html punctuation.definition.tag.html - settings: - foreground: '#FF1E1E' - -- name: html js tag url - scope: source.js.embedded.html string.quoted.double.html - settings: - foreground: '#FF9D9D' - -- name: Attribute - scope: entity.other.attribute-name - settings: - foreground: '#7349BEFF' - -- name: Meta Toc List - scope: meta.toc-list - settings: - background: '#162C1AFF' - foreground: '#BEFEC7FF' - options: underline - -- name: js variable readwrite - scope: meta.initialization, variable.other.readwrite.js - settings: - foreground: '#FF9122' - -- name: js variable dollar - scope: meta.initialization, variable.other.dollar.js - settings: - fontStyle: italic - foreground: '#FF9122' - -- name: js object - scope: variable.other.object.js - settings: - foreground: '#FFEE00' - -- name: js object with parent - scope: meta.property-name.js variable.other.object.js - settings: - foreground: '#FFFF88' - -- name: support.variable.property.js - scope: support.variable.property.js - settings: - foreground: '#3399FF' - -- name: variable.other.dot-access - scope: variable.other.dot-access - settings: - foreground: '#66FFDD' - -- name: variable.other.property.js - scope: variable.other.property.js - settings: - foreground: '#37C1BE' - -- name: punctuation.section.scope.square.js - scope: punctuation.section.scope.square.js - settings: - foreground: '#FF2404' - -- name: punctuation.section.scope.round.js, meta.brace.round - scope: punctuation.section.scope.round.js, meta.brace.round - settings: - foreground: '#1C38FF' - -- name: punctuation.definition.arrow.js - scope: punctuation.definition.arrow.js - settings: - background: '#001133' - fontStyle: bold - foreground: '#AA00FF' - -- name: entity.arrow.function.js - scope: entity.arrow.function.js - settings: - background: '#001133' - fontStyle: bold - foreground: '#AA00FF' - -- name: variable.language - scope: variable.language - settings: - foreground: '#AA0044' - -- name: variable.language.prototype - scope: variable.language.prototype - settings: - foreground: '#FF6600' - -- name: support.class.error.js - scope: support.class.error.js - settings: - foreground: '#FF5522' - -- name: support.class.builtin.js - scope: support.class.builtin.js - settings: - fontStyle: italic - foreground: '#FFEE00' - -- name: support.class.node.js - scope: support.class.node.js - settings: - foreground: '#1224FE' - -- name: entity.name.function.node.js - scope: entity.name.function.node.js - settings: - foreground: '#D84014' - -- name: support.keyword.node.js - scope: support.keyword.node.js - settings: - fontStyle: bold - foreground: '#99EF25' - -- name: variable.import.destructuring.js - scope: variable.import.destructuring.js - settings: - foreground: '#00BBFF' - -- name: other.object.key.js - scope: other.object.key.js - settings: - foreground: '#1C98C1' - -- name: meta.accessor.js punctuation.definition.parameters - scope: meta.accessor.js punctuation.definition.parameters - settings: - foreground: '#005588' - -- name: storage.type.accessor.js - scope: storage.type.accessor.js - settings: - background: '#001122' - fontStyle: bold italic - foreground: '#0066AA' - -- name: entity.name.module.js, variable.import.parameter.js, variable.other.class.js - scope: entity.name.module.js, variable.import.parameter.js, variable.other.class.js - settings: - background: '#220011' - foreground: '#FF0044' - -- name: storage.type.module.js, storage.type.export.js, storage.type.import.js, storage.type.from.js - scope: storage.type.module.js, storage.type.export.js, storage.type.import.js, storage.type.from.js - settings: - background: '#222211' - foreground: '#CCCC44' - -- name: storage.type.class.js, storage.type.extends.js - scope: storage.type.class.js, storage.type.extends.js - settings: - background: '#001122' - foreground: '#0044AA' - -- name: 'meta.function.call.class.static.js ' - scope: 'meta.function.call.class.static.js ' - settings: - foreground: '#880011' - -- name: variable.other.class.static.js - scope: variable.other.class.static.js - settings: - foreground: '#AA0066' - -- name: entity.name.accessor.js - scope: entity.name.accessor.js - settings: - background: '#001122' - fontStyle: bold italic - foreground: '#00FFCC' - -- name: entity.name.method.js - scope: entity.name.method.js - settings: - background: '#110022' - fontStyle: italic bold - foreground: '#AA00FF' - -- name: meta.method.js - scope: meta.method.js - settings: - fontStyle: bold - foreground: '#660099' - -- name: storage.type.function.js - scope: storage.type.function.js - settings: - fontStyle: bold - foreground: '#99CC44' - -- name: string.quoted.single - scope: string.quoted.single - settings: - foreground: '#88FFAAAA' - -- name: variable.other.quasi.js - scope: variable.other.quasi.js - settings: - foreground: '#FF0099' - -- name: string.quasi.js - scope: string.quasi.js - settings: - foreground: '#00FF00' - -- name: punctuation.quasi.element - scope: punctuation.quasi.element - settings: - foreground: '#008800' - -- name: entity.quasi.tag.name.js - scope: entity.quasi.tag.name.js - settings: - foreground: '#FFFF00' - -- name: meta.group.braces.square, punctuation.destructuring - scope: meta.group.braces.square string.quoted.single, punctuation.destructuring - settings: - foreground: '#47E9AC' - -- name: string.quoted.double - scope: string.quoted.double - settings: - foreground: '#11BB11' - -- name: punctuation.section.scope.curly.js - scope: punctuation.section.scope.curly.js - settings: - foreground: '#F9044E' - -- name: meta.delimiter.object.comma.js - scope: meta.delimiter.object.comma.js - settings: - foreground: '#00FFFF' - -- name: meta.group.braces.curly string.quoted.single - scope: meta.group.braces.curly string.quoted.single - settings: - foreground: '#16B853' - -- name: support.function - scope: support.function - settings: - foreground: '#B532FF' - -- name: punctuation.definition.string.begin.js - scope: punctuation.definition.string.begin.js - settings: - foreground: '#D2E20C' - -- name: punctuation.definition.string.end.js - scope: punctuation.definition.string.end.js - settings: - foreground: '#CEA30D' - -- name: instance constructor - scope: meta.class.inheritance, meta.instance.constructor - settings: - fontStyle: italic underline - foreground: '#E81E41' - -- name: entity.name.class.js - scope: entity.name.class.js - settings: - background: '#00FFFF33' - fontStyle: italic - foreground: '#00FFFF' - -- name: entity.name.extends.js - scope: entity.name.extends.js - settings: - background: '#00FF9933' - fontStyle: italic - foreground: '#00FF99' - -- name: function call - scope: meta.function-call entity.name.function - settings: - foreground: '#5B24FF' - -- name: function call with args - scope: meta.function-call.function.with-arguments.js - settings: - foreground: '#33FF00' - -- name: js brace - scope: meta.brace.curly.js - settings: - foreground: '#FF0099' - -- name: js paren - scope: meta.brace.round.js - settings: - background: '#000000FF' - foreground: '#D0C5FEFF' - -- name: js constant escape - scope: constant.character.escape - settings: - foreground: '#10CF62FF' - -- name: pseudo-class - scope: "meta.selector.css entity.other.attribute-name.tag.pseudo-class" - settings: - foreground: '#4FBC4B' - -- name: css selectors - scope: entity.namespace.unicode.css - settings: - foreground: '#FF4F4F' - -- name: entity.other.attribute-name.id - scope: entity.other.attribute-name.id - settings: - background: '#0B0028FF' - foreground: '#F20073FF' - -- name: class name - scope: meta.prototype support.class - settings: - foreground: '#FF0099' - -- name: support object - scope: support.object - settings: - fontStyle: bold - foreground: '#FFEE00' - -- name: class name prototype - scope: meta.prototype support.constant - settings: - foreground: '#FF6600' - -- name: prototype declaration - scope: meta.prototype.declaration.js - settings: - fontStyle: bold - -- name: js undefined - scope: constant.language.undefined.js - settings: - foreground: '#555588' - -- name: variable.other.constant.js - scope: variable.other.constant.js - settings: - background: '#003311' - foreground: '#00FF33' - -- name: 'false' - scope: constant.language.boolean.false - settings: - foreground: '#AAAA55' - -- name: 'true' - scope: constant.language.boolean.true - settings: - foreground: '#CC7744' - -- name: js null - scope: constant.language.null.js - settings: - foreground: '#558855' - -- name: css#id punctuation - scope: punctuation.definition.entity.id.css - settings: - background: '#0B0028' - foreground: '#FF489F' - -- name: css.class - scope: "entity.other.attribute-name.class, source.css.less entity.other.attribute-name.class.css" - settings: - background: '#0B0028' - foreground: '#9529B8' - -- name: css.class puntuation - scope: punctuation.definition.entity.class.css - settings: - background: '#0B0028FF' - foreground: '#CD87E4FF' - -- name: css pseudo element - scope: entity.other.attribute-name.pseudo-element.css - settings: - background: '#0B0028FF' - foreground: '#FF00FFFF' - -- name: css property-name - scope: support.type.property-name.css - settings: - foreground: '#B8EFECFF' - -- name: css @at-rule - scope: meta.preprocessor.at-rule keyword.control.at-rule - settings: - foreground: '#D7C271FF' - -- name: css color - scope: "constant.other.color.rgb-value.css, support.constant.color.w3c-standard-color-name.css" - settings: - foreground: '#FB7720FF' - -- name: css constants - scope: support.constant.property-value.css - settings: - foreground: '#7CE85EFF' - -- name: Puncation Termination - scope: punctuation.terminator, punctuation.separator - settings: - foreground: '#4BFCF8FF' - -- name: css constructor.argument - scope: meta.constructor.argument.css - settings: - foreground: '#8F9D6AFF' - -- name: diff.header - scope: meta.diff, meta.diff.header, entity.name.namespace - settings: - background: '#0E2231FF' - foreground: '#F8F8F8FF' - -- name: diff.deleted - scope: markup.deleted - settings: - background: '#420E09FF' - foreground: '#F8F8F8FF' - -- name: diff.changed - scope: markup.changed - settings: - background: '#4A410DFF' - foreground: '#F8F8F8FF' - -- name: diff.inserted - scope: markup.inserted - settings: - background: '#253B22FF' - foreground: '#F8F8F8FF' - -- name: 'Markup: Italic' - scope: markup.italic - settings: - fontStyle: italic - foreground: '#6AD500FF' - -- name: 'Markup: Underline' - scope: markup.underline - settings: - foreground: '#E18964FF' - options: underline - -- name: 'Markup: Quote' - scope: markup.quote - settings: - background: '#FEE09C12' - fontStyle: italic - foreground: '#E1D4B9FF' - -- name: 'Markup: Heading' - scope: markup.heading, markup.heading entity - settings: - background: '#DE3280FF' - foreground: '#FFFFFFFF' - -- name: 'Markup: List' - scope: markup.list - settings: - foreground: '#6657EAFF' - -- name: 'Markup: Raw' - scope: markup.raw - settings: - background: '#B1B3BA08' - foreground: '#578BB3FF' - -- name: 'Markup: Comment' - scope: markup comment - settings: - foreground: '#F67B37FF' - -- name: 'Markup: Separator' - scope: meta.separator - settings: - background: '#242424FF' - foreground: '#60A633FF' - -- name: Log Entry - scope: meta.line.entry.logfile, meta.line.exit.logfile - settings: - background: '#EEEEEE29' - foreground: '#F8F8F8FF' - -- name: Log Entry Error - scope: meta.line.error.logfile - settings: - background: '#751012' - foreground: '#F8F8F8' - -- name: JSON property top - scope: meta.structure.dictionary.json string.quoted.double - settings: - background: '#111111' - foreground: '#1144BB' - -- name: JSON property level 2 - scope: "meta.structure meta.structure.dictionary.json string.quoted.double" - settings: - foreground: '#1122BB' - -- name: JSON property level 3 - scope: "meta.structure meta.structure meta.structure meta.structure.dictionary.json string.quoted.double" - settings: - foreground: '#2938EB' - -- name: JSON property level 4 - scope: "meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.json string.quoted.double" - settings: - foreground: '#6D7EF1' - -- name: JSON property level 5 - scope: "meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.json string.quoted.double" - settings: - foreground: '#B3BBF7' - -- name: JSON value - scope: meta.structure.dictionary.value.json string.quoted.double - settings: - foreground: '#AA00AA' - -- name: JSON value level 2 - scope: "meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double" - settings: - foreground: '#BF00BF' - -- name: JSON value level 3 - scope: "meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double" - settings: - foreground: '#FF00FF' - -- name: JSON value level 4 - scope: "meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double" - settings: - foreground: '#FF40FF' - -- name: JSON value level 5 - scope: "meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double" - settings: - foreground: '#FF80FF' - -- name: JSON value string punctuation - scope: "meta.structure.dictionary.value.json string punctuation.definition.string.double" - settings: - foreground: '#8409FF' - -- name: JSON array value - scope: meta.structure.array.json string.quoted.double - settings: - foreground: '#5522AA' - -- name: JSON array value level 1 - scope: "meta.structure meta.structure meta.structure.array.json string.quoted.double" - settings: - foreground: '#7017C8FF' - -- name: JSON array value level 2 - scope: "meta.structure meta.structure meta.structure meta.structure meta.structure.array.json string.quoted.double" - settings: - foreground: '#9541E9FF' - -- name: JSON array value level 3 - scope: "meta.structure meta.structure meta.structure meta.structure meta.structure.array.json string.quoted.double" - settings: - foreground: '#BA83F1FF' - -- name: JSON array value level 4 - scope: "meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.array.json string.quoted.double" - settings: - foreground: '#DFC6F9FF' - -- name: JSON prop string punctuation - scope: "meta.structure.dictionary.json string punctuation.definition.string" - settings: - foreground: '#66BBDDFF' - -- name: JSON array string puntuation - scope: "meta.structure.array.json string punctuation.definition.string" - settings: - foreground: '#416BE9FF' - -- name: JSON array brackets - scope: meta.structure.array.json punctuation.definition.array - settings: - foreground: '#FCC401FF' - -- name: JSON object braces - scope: "meta.structure.dictionary.json punctuation.definition.dictionary" - settings: - foreground: '#FEDF76FF' diff --git a/Packages/JSX/Next.tmTheme b/Packages/JSX/Next.tmTheme deleted file mode 100644 index 2ffcf82..0000000 --- a/Packages/JSX/Next.tmTheme +++ /dev/null @@ -1,1868 +0,0 @@ - - - - name - Next - settings - - - settings - - activeGuide - #3333FFFF - background - #000000 - bracketsBackground - #FF00AA66 - bracketsOptions - background - caret - #FF0099 - foreground - #E6E6E6 - guide - #33333388 - gutter - #6600FF33 - invisibles - #404040 - lineHighlight - #FF009933 - multiEditHighlight - #00FF0022 - searchHighlight - #FF00AA99 - selection - #00FFFF44 - stackGuide - #333333CC - - - - name - bracket.curly - scope - bracket.curly - settings - - background - #FF44AA - foreground - #3399FF - - - - name - bracket.square - scope - bracket.square - settings - - background - #2266CC - foreground - #FF8800 - - - - name - bracket.round - scope - bracket.round - settings - - background - #9922FF - foreground - #00FF00 - - - - name - bracket.quote - scope - bracket.quote - settings - - background - #00FF00 - - - - name - comment - scope - comment - settings - - fontStyle - italic - foreground - #646464FF - - - - name - Invalid - scope - invalid - settings - - background - #FF000022 - - - - name - constant - scope - constant - settings - - foreground - #3387CCFF - - - - name - Keyword - scope - keyword - settings - - foreground - #E28964 - - - - name - constant.numeric - scope - constant.numeric - settings - - foreground - #FFFF66 - - - - name - Storage - scope - storage - settings - - foreground - #99CF50 - - - - name - storage.modifier - scope - storage.modifier - settings - - foreground - #CF5099 - - - - name - storage.self - scope - storage.self - settings - - fontStyle - bold - foreground - #CC0033 - - - - name - storage.type - scope - storage.type - settings - - foreground - #CF9950 - - - - name - Support - scope - support - settings - - foreground - #8A5C8DFF - - - - name - entity.name.function - scope - entity.name.function - settings - - foreground - #BB00FF - - - - name - keyword control - scope - keyword.control - settings - - foreground - #FF00FF - - - - name - keyword.control.declaration - scope - keyword.control.declaration - settings - - foreground - #8888AA - - - - name - keyword.control.module - scope - keyword.control.module - settings - - background - #FFFF3333 - foreground - #FFFF33 - options - underline - - - - name - keyword.control.flow - scope - keyword.control.flow - settings - - background - #110300 - fontStyle - bold - foreground - #FF6600 - - - - name - keyword.control.conditional - scope - keyword.control.conditional - settings - - foreground - #FF00FF - - - - name - keyword.control.trycatch - scope - keyword.control.trycatch - settings - - foreground - #FF0033 - - - - name - keyword.control.loop - scope - keyword.control.loop - settings - - foreground - #009999 - - - - name - keyword.control.switch - scope - keyword.control.switch - settings - - foreground - #999999 - - - - name - keyword operator - scope - keyword.operator - settings - - foreground - #FF0080 - - - - name - Function arg - scope - meta.function.argument, variable.parameter, meta.parens.c - settings - - foreground - #77FF11 - - - - name - - scope - punctuation.section.embedded - settings - - background - #0D0D0D37 - foreground - #00D3FFFF - - - - name - keyword.other.unit - scope - keyword.other.unit, keyword.unit.css - settings - - foreground - #80FF00FF - - - - name - invalid.illegal - scope - invalid.illegal - settings - - background - #562D56BF - foreground - #FD5FF1FF - - - - name - string.quoted source - scope - string.quoted source - settings - - foreground - #DAEFA3 - - - - name - string constant - scope - string constant - settings - - foreground - #CFED81 - - - - name - string.regexp - scope - string.regexp - settings - - foreground - #6FFF17 - - - - name - punctuation.definition.string - scope - punctuation.definition.string - settings - - background - #15151501 - foreground - #B4FF82 - - - - name - string.regexp.special - scope - string.regexp constant.character.escape, string.regexp source.ruby.embedded, string.regexp string.regexp.arbitrary-repitition - settings - - foreground - #00D505 - - - - name - string.regexp punctuation keyword - scope - string.regexp punctuation keyword - settings - - foreground - #C559FF - - - - name - string variable - scope - string variable - settings - - foreground - #8A9A95 - - - - name - support.function - scope - support.function - settings - - foreground - #FCF352FF - - - - name - meta.tag - scope - meta.tag - settings - - foreground - #4F9EFFFF - - - - name - meta.tag entity - scope - meta.tag entity - settings - - foreground - #157EFF - - - - name - HTML/XML tag attribute value - scope - meta.tag string.quoted.double.html - settings - - foreground - #E07D2C - - - - name - html5 tag - scope - meta.tag.block.any.html.html5 - settings - - foreground - #E88BFCFF - - - - name - html5 tag entity - scope - meta.tag.block.any.html.html5 entity - settings - - foreground - #D730FAFF - - - - name - meta.tag.inline - scope - source entity.name.tag, source entity.other.attribute-name,meta.tag.inline, meta.tag.inline entity - settings - - foreground - #87A7E2FF - - - - name - html js tag - scope - source.js.embedded.html entity.name.tag.script.html - settings - - foreground - #FF3535 - - - - name - html js tag braces - scope - source.js.embedded.html punctuation.definition.tag.html - settings - - foreground - #FF1E1E - - - - name - html js tag url - scope - source.js.embedded.html string.quoted.double.html - settings - - foreground - #FF9D9D - - - - name - Attribute - scope - entity.other.attribute-name - settings - - foreground - #7349BEFF - - - - name - Meta Toc List - scope - meta.toc-list - settings - - background - #162C1AFF - foreground - #BEFEC7FF - options - underline - - - - name - js variable readwrite - scope - meta.initialization, variable.other.readwrite.js - settings - - foreground - #FF9122 - - - - name - js variable dollar - scope - meta.initialization, variable.other.dollar.js - settings - - fontStyle - italic - foreground - #FF9122 - - - - name - js object - scope - variable.other.object.js - settings - - foreground - #FFEE00 - - - - name - js object with parent - scope - meta.property-name.js variable.other.object.js - settings - - foreground - #FFFF88 - - - - name - support.variable.property.js - scope - support.variable.property.js - settings - - foreground - #3399FF - - - - name - variable.other.dot-access - scope - variable.other.dot-access - settings - - foreground - #66FFDD - - - - name - variable.other.property.js - scope - variable.other.property.js - settings - - foreground - #37C1BE - - - - name - punctuation.section.scope.square.js - scope - punctuation.section.scope.square.js - settings - - foreground - #FF2404 - - - - name - punctuation.section.scope.round.js, meta.brace.round - scope - punctuation.section.scope.round.js, meta.brace.round - settings - - foreground - #1C38FF - - - - name - punctuation.definition.arrow.js - scope - punctuation.definition.arrow.js - settings - - background - #001133 - fontStyle - bold - foreground - #AA00FF - - - - name - entity.arrow.function.js - scope - entity.arrow.function.js - settings - - background - #001133 - fontStyle - bold - foreground - #AA00FF - - - - name - variable.language - scope - variable.language - settings - - foreground - #AA0044 - - - - name - variable.language.prototype - scope - variable.language.prototype - settings - - foreground - #FF6600 - - - - name - support.class.error.js - scope - support.class.error.js - settings - - foreground - #FF5522 - - - - name - support.class.builtin.js - scope - support.class.builtin.js - settings - - fontStyle - italic - foreground - #FFEE00 - - - - name - support.class.node.js - scope - support.class.node.js - settings - - foreground - #1224FE - - - - name - entity.name.function.node.js - scope - entity.name.function.node.js - settings - - foreground - #D84014 - - - - name - support.keyword.node.js - scope - support.keyword.node.js - settings - - fontStyle - bold - foreground - #99EF25 - - - - name - variable.import.destructuring.js - scope - variable.import.destructuring.js - settings - - foreground - #00BBFF - - - - name - other.object.key.js - scope - other.object.key.js - settings - - foreground - #1C98C1 - - - - name - meta.accessor.js punctuation.definition.parameters - scope - meta.accessor.js punctuation.definition.parameters - settings - - foreground - #005588 - - - - name - storage.type.accessor.js - scope - storage.type.accessor.js - settings - - background - #001122 - fontStyle - bold italic - foreground - #0066AA - - - - name - entity.name.module.js, variable.import.parameter.js, variable.other.class.js - scope - entity.name.module.js, variable.import.parameter.js, variable.other.class.js - settings - - background - #220011 - foreground - #FF0044 - - - - name - storage.type.module.js, storage.type.export.js, storage.type.import.js, storage.type.from.js - scope - storage.type.module.js, storage.type.export.js, storage.type.import.js, storage.type.from.js - settings - - background - #222211 - foreground - #CCCC44 - - - - name - storage.type.class.js, storage.type.extends.js - scope - storage.type.class.js, storage.type.extends.js - settings - - background - #001122 - foreground - #0044AA - - - - name - meta.function.call.class.static.js - scope - meta.function.call.class.static.js - settings - - foreground - #880011 - - - - name - variable.other.class.static.js - scope - variable.other.class.static.js - settings - - foreground - #AA0066 - - - - name - entity.name.accessor.js - scope - entity.name.accessor.js - settings - - background - #001122 - fontStyle - bold italic - foreground - #00FFCC - - - - name - entity.name.method.js - scope - entity.name.method.js - settings - - background - #110022 - fontStyle - italic bold - foreground - #AA00FF - - - - name - meta.method.js - scope - meta.method.js - settings - - fontStyle - bold - foreground - #660099 - - - - name - storage.type.function.js - scope - storage.type.function.js - settings - - fontStyle - bold - foreground - #99CC44 - - - - name - string.quoted.single - scope - string.quoted.single - settings - - foreground - #88FFAAAA - - - - name - variable.other.quasi.js - scope - variable.other.quasi.js - settings - - foreground - #FF0099 - - - - name - string.quasi.js - scope - string.quasi.js - settings - - foreground - #00FF00 - - - - name - punctuation.quasi.element - scope - punctuation.quasi.element - settings - - foreground - #008800 - - - - name - entity.quasi.tag.name.js - scope - entity.quasi.tag.name.js - settings - - foreground - #FFFF00 - - - - name - meta.group.braces.square, punctuation.destructuring - scope - meta.group.braces.square string.quoted.single, punctuation.destructuring - settings - - foreground - #47E9AC - - - - name - string.quoted.double - scope - string.quoted.double - settings - - foreground - #11BB11 - - - - name - punctuation.section.scope.curly.js - scope - punctuation.section.scope.curly.js - settings - - foreground - #F9044E - - - - name - meta.delimiter.object.comma.js - scope - meta.delimiter.object.comma.js - settings - - foreground - #00FFFF - - - - name - meta.group.braces.curly string.quoted.single - scope - meta.group.braces.curly string.quoted.single - settings - - foreground - #16B853 - - - - name - support.function - scope - support.function - settings - - foreground - #B532FF - - - - name - punctuation.definition.string.begin.js - scope - punctuation.definition.string.begin.js - settings - - foreground - #D2E20C - - - - name - punctuation.definition.string.end.js - scope - punctuation.definition.string.end.js - settings - - foreground - #CEA30D - - - - name - instance constructor - scope - meta.class.inheritance, meta.instance.constructor - settings - - fontStyle - italic underline - foreground - #E81E41 - - - - name - entity.name.class.js - scope - entity.name.class.js - settings - - background - #00FFFF33 - fontStyle - italic - foreground - #00FFFF - - - - name - entity.name.extends.js - scope - entity.name.extends.js - settings - - background - #00FF9933 - fontStyle - italic - foreground - #00FF99 - - - - name - function call - scope - meta.function-call entity.name.function - settings - - foreground - #5B24FF - - - - name - function call with args - scope - meta.function-call.function.with-arguments.js - settings - - foreground - #33FF00 - - - - name - js brace - scope - meta.brace.curly.js - settings - - foreground - #FF0099 - - - - name - js paren - scope - meta.brace.round.js - settings - - background - #000000FF - foreground - #D0C5FEFF - - - - name - js constant escape - scope - constant.character.escape - settings - - foreground - #10CF62FF - - - - name - pseudo-class - scope - meta.selector.css entity.other.attribute-name.tag.pseudo-class - settings - - foreground - #4FBC4B - - - - name - css selectors - scope - entity.namespace.unicode.css - settings - - foreground - #FF4F4F - - - - name - entity.other.attribute-name.id - scope - entity.other.attribute-name.id - settings - - background - #0B0028FF - foreground - #F20073FF - - - - name - class name - scope - meta.prototype support.class - settings - - foreground - #FF0099 - - - - name - support object - scope - support.object - settings - - fontStyle - bold - foreground - #FFEE00 - - - - name - class name prototype - scope - meta.prototype support.constant - settings - - foreground - #FF6600 - - - - name - prototype declaration - scope - meta.prototype.declaration.js - settings - - fontStyle - bold - - - - name - js undefined - scope - constant.language.undefined.js - settings - - foreground - #555588 - - - - name - variable.other.constant.js - scope - variable.other.constant.js - settings - - background - #003311 - foreground - #00FF33 - - - - name - false - scope - constant.language.boolean.false - settings - - foreground - #AAAA55 - - - - name - true - scope - constant.language.boolean.true - settings - - foreground - #CC7744 - - - - name - js null - scope - constant.language.null.js - settings - - foreground - #558855 - - - - name - css#id punctuation - scope - punctuation.definition.entity.id.css - settings - - background - #0B0028 - foreground - #FF489F - - - - name - css.class - scope - entity.other.attribute-name.class, source.css.less entity.other.attribute-name.class.css - settings - - background - #0B0028 - foreground - #9529B8 - - - - name - css.class puntuation - scope - punctuation.definition.entity.class.css - settings - - background - #0B0028FF - foreground - #CD87E4FF - - - - name - css pseudo element - scope - entity.other.attribute-name.pseudo-element.css - settings - - background - #0B0028FF - foreground - #FF00FFFF - - - - name - css property-name - scope - support.type.property-name.css - settings - - foreground - #B8EFECFF - - - - name - css @at-rule - scope - meta.preprocessor.at-rule keyword.control.at-rule - settings - - foreground - #D7C271FF - - - - name - css color - scope - constant.other.color.rgb-value.css, support.constant.color.w3c-standard-color-name.css - settings - - foreground - #FB7720FF - - - - name - css constants - scope - support.constant.property-value.css - settings - - foreground - #7CE85EFF - - - - name - Puncation Termination - scope - punctuation.terminator, punctuation.separator - settings - - foreground - #4BFCF8FF - - - - name - css constructor.argument - scope - meta.constructor.argument.css - settings - - foreground - #8F9D6AFF - - - - name - diff.header - scope - meta.diff, meta.diff.header, entity.name.namespace - settings - - background - #0E2231FF - foreground - #F8F8F8FF - - - - name - diff.deleted - scope - markup.deleted - settings - - background - #420E09FF - foreground - #F8F8F8FF - - - - name - diff.changed - scope - markup.changed - settings - - background - #4A410DFF - foreground - #F8F8F8FF - - - - name - diff.inserted - scope - markup.inserted - settings - - background - #253B22FF - foreground - #F8F8F8FF - - - - name - Markup: Italic - scope - markup.italic - settings - - fontStyle - italic - foreground - #6AD500FF - - - - name - Markup: Underline - scope - markup.underline - settings - - foreground - #E18964FF - options - underline - - - - name - Markup: Quote - scope - markup.quote - settings - - background - #FEE09C12 - fontStyle - italic - foreground - #E1D4B9FF - - - - name - Markup: Heading - scope - markup.heading, markup.heading entity - settings - - background - #DE3280FF - foreground - #FFFFFFFF - - - - name - Markup: List - scope - markup.list - settings - - foreground - #6657EAFF - - - - name - Markup: Raw - scope - markup.raw - settings - - background - #B1B3BA08 - foreground - #578BB3FF - - - - name - Markup: Comment - scope - markup comment - settings - - foreground - #F67B37FF - - - - name - Markup: Separator - scope - meta.separator - settings - - background - #242424FF - foreground - #60A633FF - - - - name - Log Entry - scope - meta.line.entry.logfile, meta.line.exit.logfile - settings - - background - #EEEEEE29 - foreground - #F8F8F8FF - - - - name - Log Entry Error - scope - meta.line.error.logfile - settings - - background - #751012 - foreground - #F8F8F8 - - - - name - JSON property top - scope - meta.structure.dictionary.json string.quoted.double - settings - - background - #111111 - foreground - #1144BB - - - - name - JSON property level 2 - scope - meta.structure meta.structure.dictionary.json string.quoted.double - settings - - foreground - #1122BB - - - - name - JSON property level 3 - scope - meta.structure meta.structure meta.structure meta.structure.dictionary.json string.quoted.double - settings - - foreground - #2938EB - - - - name - JSON property level 4 - scope - meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.json string.quoted.double - settings - - foreground - #6D7EF1 - - - - name - JSON property level 5 - scope - meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.json string.quoted.double - settings - - foreground - #B3BBF7 - - - - name - JSON value - scope - meta.structure.dictionary.value.json string.quoted.double - settings - - foreground - #AA00AA - - - - name - JSON value level 2 - scope - meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double - settings - - foreground - #BF00BF - - - - name - JSON value level 3 - scope - meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double - settings - - foreground - #FF00FF - - - - name - JSON value level 4 - scope - meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double - settings - - foreground - #FF40FF - - - - name - JSON value level 5 - scope - meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.dictionary.value.json string.quoted.double - settings - - foreground - #FF80FF - - - - name - JSON value string punctuation - scope - meta.structure.dictionary.value.json string punctuation.definition.string.double - settings - - foreground - #8409FF - - - - name - JSON array value - scope - meta.structure.array.json string.quoted.double - settings - - foreground - #5522AA - - - - name - JSON array value level 1 - scope - meta.structure meta.structure meta.structure.array.json string.quoted.double - settings - - foreground - #7017C8FF - - - - name - JSON array value level 2 - scope - meta.structure meta.structure meta.structure meta.structure meta.structure.array.json string.quoted.double - settings - - foreground - #9541E9FF - - - - name - JSON array value level 3 - scope - meta.structure meta.structure meta.structure meta.structure meta.structure.array.json string.quoted.double - settings - - foreground - #BA83F1FF - - - - name - JSON array value level 4 - scope - meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure meta.structure.array.json string.quoted.double - settings - - foreground - #DFC6F9FF - - - - name - JSON prop string punctuation - scope - meta.structure.dictionary.json string punctuation.definition.string - settings - - foreground - #66BBDDFF - - - - name - JSON array string puntuation - scope - meta.structure.array.json string punctuation.definition.string - settings - - foreground - #416BE9FF - - - - name - JSON array brackets - scope - meta.structure.array.json punctuation.definition.array - settings - - foreground - #FCC401FF - - - - name - JSON object braces - scope - meta.structure.dictionary.json punctuation.definition.dictionary - settings - - foreground - #FEDF76FF - - - - uuid - 35279c3b-adad-473e-b960-fee631f4d9a5 - - diff --git a/Packages/JSX/README.md b/Packages/JSX/README.md index 75b4e96..993489a 100644 --- a/Packages/JSX/README.md +++ b/Packages/JSX/README.md @@ -1,5 +1,7 @@ # babel-sublime +Cloned from [babel-sublime](https://github.com/babel/babel-sublime). + > Only supports **Sublime Text 3**. Sublime Text 2 is no longer supported. Language definitions for [ES6+ JavaScript](http://kangax.github.io/compat-table/es6/) with [React JSX syntax](http://facebook.github.io/react/docs/jsx-in-depth.html) extensions. diff --git a/Packages/JSX/messages.json b/Packages/JSX/messages.json deleted file mode 100644 index 80aa64c..0000000 --- a/Packages/JSX/messages.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "3.0.0": "messages/3.0.0.txt", - "4.0.0": "messages/4.0.0.txt", - "5.0.0": "messages/5.0.0.txt", - "7.1.0": "messages/7.1.0.txt", - "7.1.1": "messages/7.1.0.txt", - "8.0.0": "messages/8.0.0.txt" -} diff --git a/Packages/JSX/messages/3.0.0.txt b/Packages/JSX/messages/3.0.0.txt deleted file mode 100644 index ed3a745..0000000 --- a/Packages/JSX/messages/3.0.0.txt +++ /dev/null @@ -1,4 +0,0 @@ -babel-sublime (previously 6to5-sublime) ---------------------------------------- - -6to5 is now Babel, so 6to5-sublime is now babel-sublime. diff --git a/Packages/JSX/messages/4.0.0.txt b/Packages/JSX/messages/4.0.0.txt deleted file mode 100644 index ba1483a..0000000 --- a/Packages/JSX/messages/4.0.0.txt +++ /dev/null @@ -1,4 +0,0 @@ -babel-sublime (previously 6to5-sublime) ---------------------------------------- - -Snippets have been removed. For more info see https://github.com/babel/babel-sublime/blob/master/SNIPPETS.md diff --git a/Packages/JSX/messages/5.0.0.txt b/Packages/JSX/messages/5.0.0.txt deleted file mode 100644 index 193d09e..0000000 --- a/Packages/JSX/messages/5.0.0.txt +++ /dev/null @@ -1,11 +0,0 @@ -babel-sublime -------------- - -babel-sublime no longer relies on the stock JavaScript package for any functionality. This means you can disable the stock package completely and rely solely on babel-sublime. Why would you want to that though? A few reasons: - - * node scripts without an extension that have a shebang will open with "JavaScript (Babel)" instead of the stock package. - - babel-sublime has always supported this, but because the stock package takes precedence over babel-sublime, it never really worked. - * Less clutter in the syntax menu :) - * No stock snippets. No snippets period. Since babel-sublime doesn't ship with any snippets, only your user defined ones will show up. - -See https://github.com/babel/babel-sublime#advanced-usage for more info. diff --git a/Packages/JSX/messages/7.1.0.txt b/Packages/JSX/messages/7.1.0.txt deleted file mode 100644 index 0ed6ae2..0000000 --- a/Packages/JSX/messages/7.1.0.txt +++ /dev/null @@ -1,28 +0,0 @@ -babel-sublime -------------- - -Big improvements are coming soon to support flow type annotations. You may -already start to notice some of them, like ES7 property initializers getting -properly matched. But it's coming at a cost: - -There are currently two syntax definitions supporting different builds of -Sublime Text 3 (ST2 doesn't work with either). One is the evolution of the -other using Sublime's new "sublime-syntax" format. That new format allows for -more complex matches, thus paving the way for flow support. If you're using -Sublime Text 3 dev then you're already using the new syntax, if you're -using the beta, then you're still using the old syntax. - -Here's the plan: - -1. Once the next Sublime Text 3 beta build comes out (whenever that is), I'll -be removing the old syntax from the package. Since, that means that most -(if not all) users will be able to use the new syntax. If you still need -the old syntax, Don't Panic, you can clone the repo and run it like that. -I'll put up instructions if that's thing someone wants. - -2. "Monokai Phoenix" will also go away. If you're running ST3 dev, and you're -using Monokai Phoenix, you can already switch the stock Monokai and things -will look mostly the same. The new syntax uses more generic scope names that -make it more theme friendly. - -That's all. diff --git a/Packages/JSX/messages/8.0.0.txt b/Packages/JSX/messages/8.0.0.txt deleted file mode 100644 index 69d6201..0000000 --- a/Packages/JSX/messages/8.0.0.txt +++ /dev/null @@ -1,14 +0,0 @@ -babel-sublime -------------- - -If you're on the Sublime Text 3 dev channel and using the latest Sublime -build, you should now see substantially improved JSX matching: - - 1. A few lingering edge-cases w.r.t. JSXText have been fixed. - - 2. JSX matching won't interfere with Flow annotations. This is a huge step - towards full Flow support. Before, some Flow arrays got matched as JSX - and that made a mess. Now, they won't get matched, and at worst it just - looks plain. - -That's it. diff --git a/Packages/JSX/messages/9.0.0.txt b/Packages/JSX/messages/9.0.0.txt deleted file mode 100644 index cf9f03f..0000000 --- a/Packages/JSX/messages/9.0.0.txt +++ /dev/null @@ -1,8 +0,0 @@ -babel-sublime -------------- - -* JSX indentation fixes. -* Support for https://github.com/styled-components/styled-components - - See https://github.com/babel/babel-sublime/pull/289 - -More coming up... diff --git a/Packages/JSX/package.json b/Packages/JSX/package.json deleted file mode 100644 index 3fca448..0000000 --- a/Packages/JSX/package.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "dependencies": {}, - "private": true -} diff --git a/Packages/JSX/screenshots/compare-jsx-comments-etc@2x.png b/Packages/JSX/screenshots/compare-jsx-comments-etc@2x.png deleted file mode 100644 index 6246d27264b3bedd3c11f2f5ceb5fbe69d9f9697..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 37079 zcmZ^}1z1$w_CF4yfOLm6NJ~n0cZ1R~bPU}!Lr6)9pfpIUAPgj~{VE&+^xwSf|_lnsY=k%S}p3%AZBpoOjgvnl)O)3!cVS#W&dcrR{02 z0B|riojIx=bLODOR~j5wkS#!KjKjW$kHf??zXZwv_7^IYT{e z9`1-(1X~y5tCJ4EoyYFa9nkH}q>AHLYIg5%nQexG<1eIGVdtGfA8c7uyIjNkS z9Qn8wNl|7r$wV%ouBDDhG^Br+RM*^eUr1YLyu=fWkJuKAYi@1^LteqtRX^dA8a5`p zp~J0#vrj6{BR#Y^Z}FYXUICjC&{m+Q|Mu!)I-qvekr~Yq8|#B<(f8q1C39xZ5Hj00 z>{q*OVR&2x?i?zx)ZnK6ZVMVAxj1)zJVhc5Nhc0h5&>>T0WlsN9Go?B%V>`~ zUjnVv(sC9H-{Y&3yk`6B^-6mqsn=4{tO^?1jeV=D3&q$3D}99=Y|PHC#!aCw94ypJ z@Ly-PPW@ax>A)i~8kp6UaXQ+adB^`uiJu0G*|XGp7~h&qCeV0&eO=H6go91BF=6iF zE2*fdY$}2lWk^?<m6f+GfelaC?>CVZyToXhe!xuZ9Au_M+ zm_)Gm_crKQSx%1Eb)$^7_x7-bxrR261yt2`PmZ*tlEWh+=2|~78L44@OO$`?2hF_f>w2Vv$8p)fR zbF&-k%XGqosy0PKES6^+R@)VP#U<^FcOpGfTJ zDIy@mepHl^)bT-t{mO}b%7qa=CabM{qo}&$`lT%KS@;-JFYD5_C=t%)<829XNXxkx zH58TaUsnj`KUb_-=sy=7l=|=MUju*N{~3z;$PRz~zh8y?d!D~$N!aw`rgJRwL%lc_ zi+&tYKvsx0iznDqjHzn+A_ncbef2;^M@k*CF!kvm%nY3`WMR&C^9;Slj1CH)3jWLn z^?Ygw!G+x_!Jo;fheDh1flucUaDi)j zD1z0`r?tx;--62Dz4BW=A7Oa$gt7vKwzTVH#Mdx`6ehfs@qyQ+u1c$;h=K67<>VwG zi+OhYu|4|DkPSpB?pJZy&dbA}KwyOWv1I;ThIu8wX4&kD@{jSjy}IQc_bSaBObkPe zId?J5Z>}PAI~Eh{#XMic^AO!=8ylCD3qcRN}r#BMb$oS=&>4XkYJZ)G@QqSl4H4@c5b`JQsvwi5gwb8`Xa;Ed-j+bX8 z+?8guqGh>n48A3ZsdcsJ=d9%Z-tXj!)|yYu%N3VLvUr3F~Q>;VCa{EOA*%!w7TO5*vr;xtEE{ z>Qde?@3B*J0b3b4c;DM7fEuZHK$yL{hO*{R9eUHdcHJJI=YhvolHNhdW1AV7(F3Z9 zTZnT%M#OQW1-CZ(kbhO?J83DYG9_duOYBa~ecH?Ft;-22UYuftv-e#A@-c>Dk0MJ@ ziw9D@C(xxC?5tliS<%dL3LBaAQSBh=*bG?J%JY%HLu&Rzs-MNw zlQf4W(lC5nYj1=sK}4_DoJ@Ga?7iw;Nk@;3MdEOpdxf%ky}K}jt$r3sPjdmefP;)o zypi%RU6(bHHVyf{Y{OLLwNjGA2GPriX96ugGv_ZamP|?CEXVzjZB}T<-m#E z;i@SsGL;@$_9S+Z)vaBah8Se0&y_G&xfFXLwPc(v7D(_;7%}CPI4hk z%E#du*ny16^qcDhf?R7082$ogP!JER=Y%SJ@$}^S3cwmN0i2W873DjFO8bvc2=V@F zH5P*+Cwr(lwDH$DCK>-1k{S}eWc7Vp(0W)OSXShi}_ zm^jj@oP%i6@}Yxysk+5cq}#Q>PWAItnqi_?PK2 z9ie8`xoF{;j+&w74mr#|8sSfu4pP*&=o7WOpAcJIlJTkK>v#SsMF6S)gDH;@$ZfP%NHzz0i&SQ)T z+0e!EIkf=RWSaFts4%|4b_>0Sd#>}?9COLSH3i3HACZtW?8&hcI>R%gkq7zhCC0A9 zGbe!T`-zc#CHB^s6ATscJz=TGCoA zSXO;8A>ijWx@3@_`iG&0ZgpD$yaO$3$RegbaP54 z-U4gAn`!{}pl9wFT6h?ZLR@p9Y()E+dsnf3eq*~i)m8_`QvbM^l$WcQzg^62z6I4J zPr&y#X~Kp&BQ$(k3dNhL)P9#`lf@SfQe#=^k=V?W4W=83escUu&fYnoeqqhPj&8WE zTJur($n#~Jyn`t7OGf5)AjYk@*RBLSQ0r}uv~$-MsQ{a;Of_@aLgfH(OrN}>F&n|4d42zW}8q3_`ivhTFI5@tfi@PhFk5SNY@I$ zn`&fG4CBJj{cc48CDajB6LzttY1{S|;L!Gfnkh8t<#Ze0otIO2 zW*A0c+t&Q@g%C`f(l~ePibKAhA-A%lC-0eI*pGIsO0!x#dtsP*o7I`l#?8(~@5tr1 z2mg_lulT7G{|u@y{Kq{p^xSf)@GARE+V7O^X~QADN=Qzz7c2a57_r%0d{cy6hlHA+fBA+ z0;ZAYWuJ4|yV=Zq*A6D*8(({8m>A8AYfO=2JlO6A_9=35I`p%A&fb@6bmyng>0{Si zIqvN_v>!!UfqB=9TisRDMLe1*#~0_J0LV{_sh>j$ zGcNvZEG1VcS)y|C;>qweNRAJ*O}-6NE5XKf8wt@! zKOL(1Rj9rU1i0a3cD2R_i0swMW+&6RV&2}~OIKO$YlzW5G`KvhSDv_>PE01SQZ}r! zp!7yONHtfP6~pO9B!YpY9BX6ED3rA{-_p*V31m~h9npBm!f;gcR}^KB6yna~t~S-A z;a1-SZM3{IR}bepqRZaCDgC))4vvGgEQu4351pOY|Dw2wuVKUZ8R~FrBH~qW*xiQm zF#9)}kl3JayuOPyZ_I4!S*H^^9(GeIb1mf#ndZtQa3w@V-V(nyQ2X(%@7IOz_g6wa zozm=^%|qWEHjzN<_>6Hoxw>~yfhOYDTeVti?jh=))%-&qa}YJ(V*w>NOqE(|0S z{oz~hZ@#e%_h$~d7WJ&|6XXA~;v#-!TkCgZ8@v?uEo`D_Ad;kV0y{AIlurDly!7_$ z1gyBPdmI~ofB!%OBH~VqUB{ZuR%=u#C#D$oaVfyQZZ!orw{yUilF$qK%rHy$r{hz0 zpIG{y3!=@B@BL*u%r~>lUVHl=HOW{UJ`yimr_K_*?RNuy76}~QLl8D`D*r%rtvBu9 zKA~vOSfUL(JRS)Iopw^_2dO=_9T0=+b#FK+jdrBP&WKM5L4S0wg9AG0{r$#s;ag=$ zAZwsu7Rt2J!s4%fWcp5|wgygKX~~E20!FE9wL-i z0F93$>j#SC$(E78OC!@A=l3jke`%EoWaTp|5J9A2Kj!UxoeGsR$liIs-^7C@+TQlG zWg~)tqO;tAo^8k{Ms(?%yev)v*MBQMf$Azh6N$;hi2}aT^CS1nAE`tm5jDoRvP9hc z!#*XY98p$r0o!H5rsAg7v*W7qH}1(! zpGDPpOY@_U8bx{LUZvl0aSPs;rKq=3;EH5fpGx|I*5$>HFL%%OpWWWxx$o9D-Bj!2 z?P0-J1s7ni0YDRjg>}rVfvqSHLZ{WsZ7aloqz?f}2$7``oX}W1lwL|4bPKrM`o@zD&w}2ys@qYe2`%WVD>K@v zKvS#Yn0mo(Dqu_Q0+dSN!R-oHOmfPRmZp{V2eC&SyJ>$>gl8PvS_&OedK%hZJ8=7aO>m|iR=T2U}QNxg6ht5y;z+Gqvembw-Ey`r~1Eq z**@F0BK~^;4(LJVcN$68GKoFhWZu zl^D+h_+j9WBlUV5J~2hO%DflHOCFnG>@0gG%mnvg)n*;)ZW(YtP6qA?(=M`^&BlSx z{@c6;g-~p&d*p);P|8Q@?lP{b|1f8T5LRUY{)pt*xe52G6Vqe1PD?K!Gq2(qV}XKx zvt1KowuI=XSo6wyqL^<(2KLp{!CJR6j};$>X1@7{TyZGX znmiaHN&!T6$lbgoPo(HRMA<~T<^r+(u_oKk8rs!8Ja#uPO66n7QVSx42)|O4duGTy z*K{jqU;)SbmaF97>yS`(@^GlGzlfiIW760aOX%}Vh@FF}9ZC&qezA5fw! z51rDw|49X>%?8hF)Apw#WAeQ{3e#QJx%^MoZ?89pg;|XS9*Pns`WDD*K-jBPF2<{|*CJTgK6hR0!&4g~bS`&#Hyl$k9PHpR zs%`A!Q1Q5nHnZdix6ha)BrQ}a*y}z2k{c0hSNKiC2HSY9$!>l1?9!_~cfI*Q$2E5E z<-@V`T8H$U?RBCnr~c4wjB6;Nuqi1&0@c7fA3c_PTuu{90RoU0_Ps0^BHkVUU?#j6 zW^o7l57Ht`Ah(d$gutJc%*010p=IUN3o52%_`?oYV8M5w)@`#a$ORKqhS5tC|G_r*P>1Muq%P3;y8dZQ!Dh` zX>s#Nv$H*F)3c^GrB`NS{OwlC)sJYwqb>(0`Q|I!Li8&kQO%KtX*JGfnDgTz;XiwC zU>bh=JZ1^I7v;p_?ysN*0p067^E;GpQ)EsasWM?6a31a5@al7}O>sm#!>R`C^jS3f}~02L`$3CY#C3F%~(o1LxUinY~zuYjrId&TU(Bxh>n+7d=;FR6vf! z5t)Q1G1pk20o3B%W&cVEbeF!pXH`8JH@TmE6_vpnc&DnaJ7iq1e_=2DIW^~Y zvP{7LtGj!feC2hJsu=50A6-O1r&*=t3}W_zO4=p=!6$a|B_-%!|7p%&tF=)9YoGI~ zHvlVv=64qcQStbt&F+2Kl4{!fbAM8RmM!uP;M>mma%K*9B9JrEbc;v<^OBi3NttvEbcFLnRg7{ zR*aYCm_Ke+fMv z2E*!W1CNlPu81ZJ&{Oe+S*SUeKjyse5HTe%uR~ zg_5~&&!}{M{={kx6}pB6;qNT3&#CYg^E@DMiixIX&8;B7skmKpH&1-cXLO8yF`|i`b@2oB zEl-e-)*o|TLj>!vD1KmSXN4R0u0xLhc6e}?_OiVQ3l7o8AP$*LD zW#z$Y3&JwTy7Zrb>K-29ULW(<-W!(lS@s4T`A?0$MdW-4+P>W06%-S}$_B#&NZh|% zI?^lX2`i!PBgn%~XZafPI6)F4&N3C^i zv7s2rVW)ADLc|1^_u*q{9A)Pk%^WuOY$K1jUs7kqY0m)65}pT z*|Wi6Y+RX{LOaVf<_N?#3WzRHEi%R4cJ|9S0=^`6$erg{4-L>|hUTFDEupzwScn*Un2!Qy%Jt$UfFQ7mgbJ`GQa=W@sK!B+RYIMs(=UW>;WzTb_tgOiN~ z%g2D$MUxcbsbt<_Mk^mbeO|k}e>aj0#rgo=jt{W45OD%qwF|UdBs7szXD6|FX^cl5 zZA^noo{sdQT$gG=kO+QPM(zu4kZd4`@vznj_GabIcvmOW^=o707dZ>TyhEFYSP>K9 z#p>M6d>njl(rnf{j@9(tALYm&w^Qr98;9=hEz?!ExYc#<(maPo0~u5343q7TdW1<} z?59T+h)5%*Sr5$Oj`6C4;urE_Ra}&CKs!(&_O!TU@Lx^hW{bB3I&H{bUkW!{ zsRm=87#EnKF#V3`ZU=I_zk3ZRKged@n_uQTMBI0Jfw(O3q;XSa@Sp~Lzm8>Am9oi~ zl2FD-PwILsnB1}i*5ZEiXZTgeqJ(d&r5o|PyN3ohkw*(s=j8v|LNdVy!nN#y)gzbS zyR9J(u-yB}AjkO)tkyq_>A?BT7~>|h%j;oGM}DD?G>VhcO*~O^P$y?260gEQmJYYaPmz+0X9OV=hlO3Fh2O z`!4xaUU1Q|W+x^2R%Q4!dcifOlP;jlx4UxbNK#<4aNC@+0g)B~M114L!u7yCEq~$n z^baf@V^Hq9?%I{IL!F2EI2pJTESTZPy4NuxpI4h@#d^I9LMXoc$%r^2X1~36{PVy^7vN$^EhuKhJ1Lo{W?YVr}2yWtNWd<)5@&bSV`Ti zq-6xyVK#f@@3mHys7|W=j=mx<4>)HpeQGd2i294Zr+?_1ME62JXdCUu5KTsra}pW8 zaN_#1AZU`6(P<^c#z-k%f9)cIKs6SNctck+U3REf)BZ2v-2 zZHt#8zV6Kj_0reKaNG7_I(tc(<$!c3w&WE8)n2w!X-c_L{zJ6%Phkhj#-RFEfcxa8_ z>kfS|2kk3SE!92Az8nd>zwY|f%yuN%%t{D5diT4w<&VaG12}0Et`P^i zGt!wp1U15*3%^5_zD-TOSA5{im_@##;Y}p|Ypr`)xE}PhuJS(l$M?}e z!&nvLJ%7g~tJecN8Q5+-pt_Uz`(SL~qY~9-^0n&g^v%MOGa6IB41ON(9qSqQ-r;mp zqa7r%!Qa^V{2Mz!^|tVowu`c}8F}=O*@Q|87kQ!zH+p`Gn01x#nF0=CsyO-l)DK+4 zcWbUzz~6CAr?al%PKVF2db1p@JwJ~g>BpIIichmOLskVDyR3D*F`gLp0J6S4;aD7 z0|XYshG#X#3XaRV<0a#MSLuJsxW($!v7SFSy#Xm;N0t{k9Kp|2CZa%+QLRXZuPD>V;c;*5VaA*OtU< z{!%oo^79skRw5SysTl}}ahDiNDqSq zW9-7M3AyuYS!y_L?f((3_?0;NMFYOTI)~wYVFB86jXV6`y850YV(!~bdN7%8hx~O= z>T&4f(NDLBYO@FqxZxxMj;KwJAc^&2n@%@&^NN~IVWw^(p1>1mvp)&6GaqJ^xM$Xi zI6f+6@>%$dd-a_|8;<8SRsUK z(_^JJ3it1WhS0koBga3eSMm5z$==06B%#zmod4e@AoQOB|Et-K{7>)yYQDq#r}uv~ z;p_iv0BSnapKAI0clX1k&OS>L3czX<-^&kJ^4OvrfDp}VcY2jKpmlS6TE1L2j;Lh+ zw0RmLl~2S#(r0_Q39k*R7fm#iKF_9+YH}wvZ&_c@Zk#YYbn=@R4;s&*E6@hjI@!?iv)d@fJ%sa zP}n{4k#fal+6FDcxw25r-HVH`iS#Wr%f7SCxJVMNu|6c?0$Id_$K%>50;B?5wtztv z_JaZn|2L;ysbBABw(^q(WDwE|ReW_dl-RS}JUiRARdvMWuP}^0Iv}La z1fRcpk8hyYDAH&lIj*gL{RbqgUAbnDeO0Mwlg#x zje8o8gaqd3<`j$ryL)Q7+SzG_F0gxfvfUY(dF>AyPtz;Xg`1LN{5q#9RH-w>$!*D& zn#^J~%({~_HC>87sH|60GLu&E`Px~aMJZ#*Fvt+zbg=AScrRUkN9N_!9>@O4p+N>Q z@%Bm|nk?dY<9F6_7oJJU0E;eC@%7`(0OUdBhamV=vS*ye>Qse$dBz4YAMBPWuYhen zht-eFCp-_`=E?n4%w5H+Z-^}?&iCr}{4O-Qo~W*$oL!^U#+E3UEyG^E@Bf7K4bASF z+Pt2PKZ6^$<_Iyo=|VUMgG^!G>SErL3D*nM2=re|yY6L=GzW~QNye<9;Nvdu&C+6OgtqI;?4=%P7Kr<9()l=trYV?9vQiL`O{_z$T&l|w5?oY`)d12ez204 z;RzSZ+skPk`<0;j!u3)I9)LC!zEh|t>;w`?edyx^lx0yvbY_fb$~Y zWa%o~?zlCUzgcF01XKK|FP49?WT9I(>G?C^jE7(C-b4?UX3MW1?XQGlBBgrdd(`d9 z%1TSA2#A^looZeb7Zg4^@xVRZb|HGBY3C z|C5xC#`c|Kd^Ql&Kj2JHk>!oc1q zb1_&8{ZVLH{W_%pql(XO=-Vh!O>Hfiaq!3QtGJRmYk6zgk?n794Gb9W%a_>hCu&$_ zMi|`B9?=F4U$5LsA!>9iK4EPJ17((2|P0-K48)tDK zlCHzY5`UpN-9ExYY(V&IRPW+<(NFKbbxnUUsz|XcQheuFvw`E`63W5I#gmjoc(Or! z7v9t-(_Chq>jjM<=VUbWk4LkBUK3v!3+Q;mj}2I^JG55dCh$jah$;`P(5h!uscBQk z_6vS~cz9{sTE}s=KcMXDct3t+UHf z(g0@M?X!jXFp74FGLRsopc6ym+{3Jt&JuyQq#nTkWh$sWR9_5oQ#>5pLp^>k{~BCW z`mACPy3t|{ zA271)-?|k;RTsah(pE>1|9nCmxH;XJV$o{WqEW-VM^v?H)`8rZcZSH+79%LY`=aLi z`Sp1@QIWmgs}spr?|vIJ`)OuDb%FVd)jjjXK8~+~*o$;bXV}VNq2Y$Re(R>mVOh^M zXn|^B$knJ^u;t^GtC4Dmt1qrSJym;+{9L_o)lyJqQuXZ9Zi;TmF;i2Ym#sIpH7#sy zd%6z&w(+$r4WYDK2YSD_GpI>x;k6Os;SLNI)5MLmKwCboQapzlqxvM7)1p^sYYu68 z(PyI-44xs`+4A&iF}cs~W?A~_cJAHA5?j8QMkH!|2`-|!;H?(zPNY&B;gT%Nwc^@W zsx)R;oBV`XJXfT9Z+QX^sNI`S^iQ+ez zM*fS~A5W0!QS~1nG6Iz?4fOrNsbhp+zkxZ~m@MJ+J)?$o z_Qf|x-c=5VLIA`N3Q$p=cBwP_MCwz&EbaacgRm$KRd+6S_>2CT9ErI1|8O` z=EWg~&V+zLZ=(evp`U3&9$H8Uq&ozioH|p4s<73ZEh(r-#SuLWU%2zXw}>lct#0~& z(22eTMDpAp+ufPH7eQrPO^7L-&MU#S|NfHKPR1~7uAiXvfS)4dCCdFQYbYk3G7fb} z^Y?)Ty}1n%`2Sx*5uu60Slqx>B3tNK5p~cwUp3(Xi5GhJG|`)nXG%d@IMHU=lKCeb zz^mj#H-2Z~m&OkP*KcY^K3O)L-96QOX$TgR$f2D@cWrQEcxhpr?lO{%5AZq7j{^6hKY%PQre|> zy|olTaO`>g(nOS0h2^oGUGav9OJ2R112Z1{)`9+yS|cHo1c!PxoKRaqYLu$RUrEs! z5(tS2Jw!1ABPY2gLY^O28HUFyx0BT9xpK)tUv6Pi7~Ow7clZKY=IfV>*N>96;> z>pLW;vLtfWnShMRF$2F-Z}z5YtG|xq0(1ST^cH>Q_5yJf23WiPB1xteli`y$pu_Xr z`6fCgMgFVjGxVMpJlkesFZh_HUm0i{070$mZk#}FG42Oe#VZpT*Fgp zV0wA$kH@1y5`Hsh)Q&8-^Op&vPw%-$L#8XXXkkZ*acmJ^5?$)M70)O&yrJ|^Q3kqW znHmD5*$VO2X5yhq1Mkihwx{#%tpz!{2H^;zNU*cvCi1xaj-1isF=V<)USv4{Qo@kF z2c`si28*;%hQvC5kqUKg<&rrfVGLPMfM1j0ifQGBxsBKDrdfxagWT(G%)|hb0(onw z^S2d77au0MCkgl@kx(X?=71tB0Q8#h;z8LJN>X-U6r-=(zsVWCu*(lLxETA82v~!M zap+Re59J>>#r3p2I+)PYU+{S-Vfs&WjowDm!W7do5Q2Qf837UeKu3!N-*T7ww_|ie z+7>_QgeSr|09h7;qd%Q5sEJ<>^}3xY@lPZ6S?Ya5VaJpo=YIMN{c*BjP;hQ9MblM8 z?^z+F@2dA|g z*{dMoL&jLa^rsXIUg;{Letn>Re% zslM#>FY9DiHmJqFn&i*kt#3PU8Vy;_R+-lKlzn%F*LRk%{md})?udiK2XvF>Wt_4O z0U(*I7Yhwcy6a<-nPY5+lU#5MNIV#-GZ3h)JkoQbrIx`1vc<4KUAO%~z;&2EY@egq z%SdCJ>N6VSJAh#n(<#!rIn*OS;Nb~D4M`xtG(>GzO@ADfjL5S^I0V(7*jV@qrE*RD z7g{4k6a^5$2h8azE%>nC-sizt$BS4WE_M3rODgHdXcvx~hZt2Cqog-Ri?s1fMzyH1 zZN@a}i0G1>R)PCl3j}=3=}X(C_Bl8+TF~7TM|@OLxW!)4Z^ZgC7Ax?zlV{LQ%OXDXB8~X6L5uP<_j}Hz)IyRwA z2tqY%V@arb9q!G=i}frcW>6ox71pF$8v8C+J_b_j?UkNPZH!Lm`xT@7=^XgmR{8R? zASCRTs-w)UHgKCwjt?w75#>wr>p}?4Q>v?RoAKSutumfl1vE00r+XFgO{XFxufyWv zuwcrtbnJ&{0s#l={?I8B~4U?a0{DXvz zPA*5oRe@|^otG0uwuK|Z@XDQDv|aj_1h7*-#r$}FiO+GvhzRp-t6mhK0lhkclIrS2 zQ9+=-zLAxAD{v(tkt!elBHe92I{W(UNK5~icVpcsDM*(iTgYgdqr(eT%a@4nm3gz8 zrDUSpXSkCaPNf6x0h`|JO!-vv3bF9~QkXOYH>L?tOHLfCD*&XQ-t~Cb7_HuLa{+zA zV3%yStv?TsDmcAGT!so2(`2ANG{Y0%MstH7g2xLfFC%n0PvEicETrr6WAFntUg{zc z6yo{Agv(RAK`kARC`Yr00h`)X0;yJ_)4!Xb#yEKEgq}$XEgb`?%rl=KHeh$xBU$^o zAGV}JNVyzH-$*r}GyU^`aPPiOrWanb;I*A}L+Lxa*BMpG4zWm3wB$mx7Q^&m7UBg8 zAP_|t4I`|?{O8W}NHMCb!NaT+EE zbl@sD^X05`Me%yrxjU^gs`qU8}5!cN8iTR2o zc@O|YRy`0@!yp?q1Z_gEQMi6AOILX@P$JnE)?=x&jI^^0zBI+B$pP!JkXK+e@T(3q z`@1H+m9Idw$Nghf z1C~E0z904`6O0_g5Ph<){D<;7+ABa@RDvt)eVOU8CmW7u7ZQJR6fWc_IGsu$Fw~p! z=k=bIjm@1wq(IXWNkJ1AC6!nGl#fM#hDPJ8kG}{TDqWr9QS(+-!v@+1eVm8y4mArE zho3=U3?WWIS`oaB;uSf+wy)XbVj@Q$!97(S5!hf!l+2s7li+M4GF-&a_N*dccL|FJ2?jxd?K}R{&M=927SLIlg zT4ESv8k>x|oDoL7>wr50l*3*MH$mD@ih4=*wBB5`#2#9>~6BBeeO6NUu}m`w_eX z<;xE=Y8Od6x~jcDXlfSIvl6~YWxKucVt*eM!VjB)V7Yp%z{@YEj?lwKZH5zs_-uFu zPyA#;t>i2+%B3}SrA^MxH%UxtZ48p9+~^UhUu6VFV$|-BFHYOD-smLjc9>jly`kCd z34;i>mx{g#j_-C@w4V{yeYes6L*8rq)rQ7b`lILli2#)B_+MM8o?6Xz>SBgsPU^$? z-Sv>RP`Ya#*i2us`O01o1U^Na*bL)_3O~+F!o(U00b7LA&u)_Z;pD%*#tz8M72Sd* z8QmWCgqdks7(I@#~K z#UB6-W~xNPCpI0~5v|ZX>}D-&L^B;TRe55+$%%Phy#v$<9(QV#V z-iMo#Lw*Jw{x}p3M-6+Viue{3Y-}0lkJ82OtOm50X@~$?7OGHM6H{YjQ~Fovb8~aC z0Nt+Q@84Ig5z>q2ZRl2!N3k$hJ1`BMvHXs5K?l){YIiQRkUMQ(LEuVw+QnV+R>ntN zW1hMIx9d+jV*0yw;MIQ@mN+H~?;7#9FeO46d#@oQiJM0p8-`GFfV^{}mQ&DStj_du zyu3{c{Iuf5>E2h*{?3G*iTzR@>+@F>2BU6X^_M~@JkIgZ2hrB3m9tSielv$+ZQ*mj zjn^>UL6VC6w7x4_@L9l9t?c`IF99U`1Dvb4gm1<(-7Wbu6wRocrIuYPk97Uhi+NB; zPYPt^`I>}X;Owz!K5~XnpextQDp#cJG_0iIOR|f~E*}Iy*R3?(74<5Zmc(iBbMFW8 zG-jr%tP7N!Bg5*Vk8=K3uyeM90+q2cmD)O)ZL0`o>({WA>@p`q-i{yg9nCJtQ~14C3UC4l zw6f3d`3#Y~x;b>tP#d$G1X5*tIQ*ud{4onwvim~xTY$D$S+U4+Ks-Gl`nJt4x&(#) z3xG}^vtcaFllg9OpOnu-oA^jXh8a9&0~&h0rp<=;cEFd+wim(YW!SHYhgL{iOU|n@ z{P6qaG$iqW5uv+q5qRfd7Hk;~yq*BZY{y?0hKCPYpYVJpATli-Q9P^AC zBoFl9e4+*06n`OMVGD+NS&9j6t0;Vu;)5oNgBAa{6iVS>R4%>gAk}kMTw^5TT!1MF zf$7BY*u(ZUYJS#PMDWzF*o$f;3D{qB@y~_AFtoHA%80fj7&Lk=}Tre9|iABQ#*}Ye`5#bcu(@{nFzWk7qnJAYr ze%G~$EoZ-5E#FCEC++||Tml32TcnQ9CmUtEY}St=TQrp?IVo|&;r4!FwUq4}orzkD zUry+OagfRP`Q!!!ZM56)Kh}>iy-;yS(MyV@mYf=Pm2cp-rxjwb!fQXk0nNu5e_dgA zh%q3UrL~0?;$i;|?%;&|Mutu7Y+$rYl7aah^m&zVMXY%FbZp7w3mdxS4xcy4M;d76 z3B~3>sD(V#>?fu^1I1WIBtY7#+|%oK9RW~=ed2JWSd0tRo0FvjO3XYL!$tU3bg$n5 zQnl5K*kW?7A@{?7vafxDEJ^1VnMpkGo}Z8j%q#=D#)I1lxoJZ5r(>R{9v(7!tJaqG zjorHj9Bsc|ts|FC(@lHU?gVahe+Z8amwy}e^tSrT+Q1|v^k%P3$v?@fJ5*K(v{it# zr2hqw{BpxkW=B1wl$Y!Rip#ey!LpY2q6U={_7>l)r8J_p#XS&H$NEqDt_m?PtO+g+ z;dTnzLiVTmQFITWFWqY`f=D0JK-EX4KlXXnrd;^q^KC)!z1!9uld0pPeCli7hCNue zYWP~#zx_aF>m*k1=`SZF8XT_bC)MGUw(?98p1{viiBbi_Q97D(%rqanHfRr>u;C$_ z&kuY%m1@>yI#pftvK|w@KO8>mAO3rE0L+GDzOo3r0lgqV9$Ok)U5s2K9UpKuyY+~S zkF&jbxUjxb4thk3eL*TVjUs%)2sEJ|cSC)^9r?P)G|5Yz5?b07CZA!2pAs4uHws~s z%u?=2c6diInyni}R@Um5Jd9pzJpzzseK`ubl*Wg8L^&P1qAEl91_W zU+49@*J0{#%DR~jZ(0a&-0$W6ecF=KLTL}RkG)lGpu@ufjO+v5qasUyA-)vY@VwFt zh3rBP-^-!#MaX)824=%B&o_}!fb_QiTRPx&{EHgEH;rfUf!X@_RtgFeG-;U$WnV4iOD+(ksXCSJMb@v?EdO{Ha5JvL;Or)1m&^fG^xJ< z?k16|pw$Gr&L20vzr@ju+8L6U97g+G8J4CJ!OpdXu|LWeZ{|Ny{)qpC@$5&XNn#&J zLOBNfMV$l%p4wcTnJ{f5xfOt_U`F#9fp_OO0t_v6TjMo92DCV z-_ikniV;8f%~J6Kt=?_p^NCWGP`2?NwDcFl_uV}=^>&$!SSZb?{^?{j@95@!x!UQI z8|*xXBfShCZ>?rWDVQXkS8}HlY<^irB75TbY^6I?e_)6fS*`cZ2ilAJ=wx2huv~B-lecMdX z{|eT)gzZ1@Xhv<`yw2Z&EkJj_iAs~F96^!*Kp$ZB&q46oyyEb4tDKpJWfycr>ZKzh zt}DqK;i$q-e(uLkHEl)r;|pcXsEx5IHDNkUXvsNxph>t$$Eq0HFM4*jIq` zaL2~-nzyxJcKuL|y5wi!L%0_vLo}w#D!nu?7CyDtjHKkUBa@rf2r=PgTm^A1Pf`1* zxw!tM#o^fCGqF>vMLHBY#!2oK8^`foQC3O1bnrr$97-M)&KAI8K zEJ&c}IS)}?TnxzZluF{;OlX{O5l5@l%k=1s-Tuf{R5C}(8q^O@k-gZDh*{sta(Ld8 z7M;g*Eav?`w%!6Pitqg!7U}Np6r>xZltxNGLV7_EWa(xJfu#kcK}w{hmhN0iQhMnY zfu&(-c-HUt_j~{E6W3gGT{Am7XYO;(-S=nCp#Nip%^6Q;0a7g^$8Wx75rR+&_?`m+ zXTtRPjz0O)KQ`Ae5&(U%wBr5ABn;WKQsVt!rGx5vE1yuUKg`Ad+MI$Mgo-M>&*Ziu z1EqPqd?!@Kk!8tPA48421Ja0xXTnt7`~w->gdK!b-bvjz^ z09DBFc^!oXD7tf;6+DiGQ%d+JUe;%Ad)(aVaN01?WHL7S=XD*$Fd?Jt-7yuBnB0^O zx2T5N`K|0Ly=Bf!8 z$%03n5m~3A{?0vMntH1=1zhpn0U@R>hqSUrW~h4B zEajE0hPF+CWE;J||Pd)6$q@(LV{ifu0UmU|(nLT0& zEBc=aqI@u!E4a;i%IM#z!AvcNOUtlef+}~VF-VuL|MpqBD+ypO$1O)I?TK0y@WqDA zq86`Y1+YHSoWgw0<=DgDuB${5R^;x(VO_brd25676Y>tW5i-f*Q;>dbCL(7D<>QOP zvXxeZO+33T$STdgeF7yt^w_A$uY^y3-7Oy7iZzH<(OqW9 zxvm)ega}aPc%;r{s6t^j+{?a_;wnG52}>%=!ljyynTXYp_|@~R&{ zqT}rsks&A!Vfm_np3$u3A!R#%D6uq{m@2m|#DdozSY0sxlWfCP&Dk3S1=3qvW)Zf|)jtuT!kl}D|+ z7f3pbAsSJzdfM@8Bb?6&Y74amkV40Pt)-|})4hjvA!GhHNPeR}-cNjf&LGoY{vI}z zwq!4)F4LXk%(7qhzC98}H;mU~eb*uB1+`8|j->JRHlkK|lK1u!FW*7BiJN|&R81vW zPsD~7vT|)H%DBv+m%TXkMks(kSeEJ7^#|aih38S2ZaUWDIb@>4ixVU}^-2RSY2~E{ z9XtKc1c}0t#nF%Epn8)^^_bB&V^*;LUjTt?`&k+GQAwA8HySV3KKNUmHEV|7$q3PT zF+cd_Cx$02n6>9_;lCmIX3-i&QZH#?_%&XH9-fYJFJ8|l>WKJiXa!686;$>!MltJj9B@};+LlSvAii6IE?mS4%-@ej z-?I1Opy*zrP2k0%j3s=pO8CUrYmMR$%?3tA?Jmti>qUBNllh_yOqk>0bET%CQyhf0 zW8MkR5k|!ZaCa_uV0tFxg_nt+8K#NXDzdTKB}6w(1cZf9FG|9D&2)zbS_jV?$Sp8W zq~Fp|Epw-zvSONIVQ<)mX2vKSDVjmMRWilI97PHue7TjWYzf z0HQa-PNPRvdaK-vDVPv`YgN=Y_UqoLdp@*ti&IlCU%ynxIKZZ z)a=s`8VtlU&MD5hJUPV1QUq$NWX<0+e?$w9rPZ;5S+n>2Ws_QfI~d=NHfAJ-*hXQ9 zsVum{Ue+(b%K7Z=E6>=|zg{ldJ`HoQDwdgp5n*dTUlfh&YcvaiHEMf>i~b9He`@V`-KYE~Ea{@i(D! zt9v`myVq#rn5Al3QDkgf6o{XMkEilJ(0(C0G}-0ha2c&Ck7=tpU9R<1+@V1SzRHl( z4#@@Hf&oPq2ouimgD;I;eE%GEx1`%5rvuY>k||9iRN7^Mu)yCh6+QDSHi*{fToQkA z5g+*rno3*Ubj=uE1!lNwe(b?*ReIgr;Lrp(A`k&KR#wAO#pfhikE&k%9a&e`#tzf~ za^Yp}dt0EhgGmiJ9)7)zfsps%uG8M+VWH)g!y=6yd||465=+qx%ae9W#xYHEHIJ!7 zpl4;perKn&vfA+sVYEY&NiAJlX%P%v1jA}=VOLpEKHo-7Z$R(d&t9LowGX9|1pmC^ z+wnJ!=`|N#Y8Vq8m5@d140k0YfuQW=2FD0>2Bl_U^4_SrGKw7&M*y|zeEqwvvR!t^s__ts{NycC-c zC;|jb^nXccffI}AMjZmVji@E0(jMWgrUl7c9J^S5%bff>{50MUz=3 z(;!ZKha6-1=&*JhOE(I@eix{?p?~wl<9EqJzfYE!bA00fCc5xg&TdIEQx}1oCed^WRDj7R2G3Ggz*kf;{wIEYl5h~ts2 z)yVe+vAFs5znIL>DDguIq+hWKl+`K~6!J$t5qY<5dbQPmGqj@u=>IQo1ew3}TE~2j zmt+MH-kd{%Ls^00$i%HvxU2=4z=Zh9uXhMO3r?yyh&D93k6id2Y(ydwf;$Xx2tr75 zZ3_{16>;gUkS8a`6q}l{b6PbdD@aj#Vk28|fPD=c{oILltK~|-rA8z8uwnVF@=?HM zXgP%F{+_JNYp5mk2)VjSbhV2_k3lPip??JO|Fu|B=4N`P@2dLj1j|aavQp<2$Z-dE z`F(Hv!xphg-4r2f2O=#DWb>*^?931=4nJ_f6|#{>02q05K33~R$i_rKC6V+nr<hC9}+SFDC0ePR*3DgJ%)4uN3NnE-BmHsUDe(@kNsat z_RAtG)t8*Z(s!lgBBt4e^H|}?Rk*4cL3kP<4%|#?equyzf2qYB5$}0X-VzNXS>}FO z*}e=HLj0>+=*tcL<6*ks_%sJca0ukjXi>X>)Q@cXe^RlPNYJOg{)sB5nM&FbsF&@s zqjUVYnnFH9zI8#Y)Mk>mr{>7IWF8|0_TD6>^dTLU7|aUP&rGI06zK@aY-8@}vF%p} zx35TxS(scDWtZgDc^g#s>AP7c=?K>RrjzRLLDPHfi>ZsU&G+j%%3}2{x zfT-(`s5IE7m(}duBy!1OWNTO)^fkPn3c3Z*HW`BwqPKUCHciLDbD}CRUbXATIA}ks zeG2A(acR#f5OzJp2>(Q8!B(N39Ge)?WA2caO79dLtLfTrLmz|01B~UwRJtIU#UK6< z@nPPzXm#;Ox_KIxkV9?wgtpHD7{SGi0W|x4)fAHJo}-d*Oin=9C zyVJqN@xE??S~7)z<7f)d-?oSCm-PA5-o?we{j|eDQGoseA)Spqv6ed|E;Bux`+NCV z)dPRwbftRH-Sk1c=O{7aK@S-`EEk`${TH{yU;_|tdyS?CDmr(M$)L!^vy+HsRto>dP%%aFBJ=ZJ z7^8k-autqkNEOulq(cO5N;cdG5yj2K2Z`8&nHH0t1uFEu&&`uDmm4nLpM*ikd~6*$ zs$`tj42W78?v|OaNJ{U!6NnwZ@)=wd;B`fpY?^;}o_r+OcX!o&xE5zrLK9Ay1E^>- zB!<^p=CARZkoeu%>e9-6G$MXCJbKSqKNV5Rxnzn=#;cFMwq}<|M9b5Z@G>ip z1HJzb(L&hV4VW}whj9tJvI6r`D(^Fh<@+*yiM+nI-Tebh(dNrF4dnhyc=EidH7m{! zhmmwLeS=$%cG_)pc1C<=51CMn7l(ew|2vRG_|TghUfY*p9&~OS#N-x&O59wQz<6JP zdITo^#A=ep>M}Lglm=rBegVEKPSH&&cKFfkPV{=XG#04ODg!|Nm&iIho=SK0*Lb&2 zfAL@W*waM6YH4Uqxkgb=-#gPT+HBxn5aETzrl}UiEAqpBu=geHlFIhTzB&2cVD%@- z8ClW@36pu@0>*d$UFdn@Bic*5k|jYUSwg&xw_V<1pcPJNr;WKs(}Jg5k4LEJg+%H@ zGCF$M<&;YED`ylf?t6*FmP!Z>BJq;tkj10N0i@V!gJa+N4eOWPl&$xTI?kn}WR&$p zRwi7$(MfR=8zs(MFWpF>|{7h#dYbMYdz9foI6!f5(URWV#>e zr32Lv>cAq_!D>;4_+l9;arQTF1@2G!eNuk0q$7Ml{w`>Z_$!x7?v18-$ymJ>o}&#W zh~>$6_U{hixw{ftVWY>w^n!s*EPc96G;xC&^8u$bPqxG5sqbDC6aKcm%82{R<4Ul0 zVk?+$;rnWhq0pZ;NKAU=k^5o((O)w)y8qXb@%CVh6;}2&thUe18M?+x;EtpQ1h_yM zk%oyvOgM)HZfPd0v99t@)D8F9bm|t^=|RS`{|(>CK7#+xa31nM!TskMtV{sXx*{L< zkG(`zO8-5(y;XYHbtdE#MwSTP!Q%Z%-q^w*;|shLb%Xpa`|B&`_Cv`Fx!tkOsoB{k zLW6nPF)e8Bm1?mHfN_SzGnTrM9s)uY7`kr^y3ftP;hIn(n|<$9Oz4N5q7Rs>o0&P} zXr->tfGJIHheCzzGr~s0>2pFv;dA!a9G6kgD^> z^>c6gi(z-;G%K^u?YM84xDa+mHCT>nTop5ZypZ$X<{mH5ycc#3GN*EZIxP%6#Z^py zn}=(nDdoG->uW)h8uWa%eY=g6Kl;y4(wN_^3jzNYD8(x=x&DQ*7urxD=EGRwKAK$8 zH_f_6G%?YG!Fx0ae?o6B>@c@6AX^8@*9Qy+ z0y>9;@_l#hACRzYqvwUvJ|JC=3c2yrPu3FwRg&Wl$^XGsJN$Y=Bf?vyDv#n_4RH@+ z1quxR8#Cu`wg{c+TAQ0?8@@P+tSEXJU>|z6uus7nTQq(>zCiyg=r05rX7Okl6chx) zM>cZlA#MZXGc|5&&d`>-_vpO-eKlG9@&)M!|0C{%Ka1n(Limcni`-iHxVjp~0A58J$OEvNz{el;8RLLkPXzbYIl?e%4dWL>Rc^{e zJ#nCE%#+znBAe|!nUm%aNc2MiC#1vs?6Of6bi5A|>s8^uv95F_N)5#~USl=IB z5M3upWLFZG2djd;hPHCwGUJ-mzr<)AKW>)gN^3p~%>iTz*)rNH+*9LA>6i!lUXyMo z0d@x~c;L0@$Tci?K5+ghS2o+fIE4F|y~J6}M`48vQ+pvfHvJU`Jrd=csmDPy!2-3| zzZrXJrcg1Edlx(y=I&F^!GUJ4rqo`|*1VP-kFpyFh!U{}h1FGVt zoV>x0DJwfLZZ9YHvbO=HsNdj)FAE4kbM{B)ZbL9cSeFi7rdm%U3TbkGMopeufPRobPFcUB+qBDQWH2(70Stdq=(?9;%VoK}-_ea&(P`Y>@>kJM=y}HyEW!*xlhRW-|s6yu6=fo6|0(&Lz99ZXifYW^L_d7YYp1tZH{l~AK{nmcqDhm;1+rnG@tPEd z-={73MGZebMdqMnz8=4Te^i;OezyjBFcJ7x&UGn;i3D+>y^C1RM9{U9ea*#(hOceV zu53wQD=PLRzkXL~=_1*D0ln}QwH9UdS!i->M`rA7g5O%GEd6=%h zrE}xn*`(4_%PIl{=~FAA2mTUSww5?NXbWc?(ZMRfc@5k5k`2GJ+?h+p3L82dsiHN4 z`64Ze<)1JiPpjTKF=g-@%FiXdOH{mEgdF2z`A0Xh1MwZ1FNwXbEawKwta^cxc)kb4 z1*ZMTWEdYE4G6>?b6m`f3FYVYaVASr_fc~ zD*?>HiX`&*-DB+7i8f7805A84Y_=N$WtRfr63Y!Y10O>#ZQ1ob)0Z0#(%bcNcTS* zza{Lyn+Rx*l4iiOJ<}%!GnkEq;yV$pI?p@69@vxIuFK&(f~rgcjY|=RGVo2G4u+W- zX;DrhRg*Uvz^U_IPNe1=VQ14COV!qbrNT?z%FR12S3#Dhp9&)o0n~lLg4s~RZw-UH zGQuCE%c{Jklk~T2lWt2DK|4!QtM+{U*B*x%^N-AR(1x0KCeuXU&t`rR+}?QVs6+al zVi?8ipjx6|@#7-6i7Y`7` zgJ8ZaZ{Vk^B>^q_2ztU>jatLrm;EADk)j(v>{tAatU|A6Wj7AfykMmk{l1K(xX4>= z8H7KpZ>(GX#(WN&1?$L_(|hsMX=GFg#x9R;EsW;*zL%*l2Qi%82R=PDyA8CDh_&E4 z7C-rdCRINc(!Or4eINlG6z9VrRnD#i4D^iX{SL0YAjN4LXla4IRjI632IHUJA0pJH zfDgK7>q1VnF-t2x>7ZSFWWedO^GQrg& zMgfZ_hnP;GUa*8JnS1>O0yv`er>7UJc(&2_OJzbL*6*@@M6Yg5%Ve7u%;00RHUxGW zhU?XzTz#_L(J>X=_-*~uX#ONDowa#4G1OJL^WCl=@7Gpo4*7(_i&1GK*eqN5%pETO z&kM~!?Lm11gTc(zq;Jwc1}VGHnEmIgizb1qZLIybH)ESrS4=^k9au|*OZ*2A1wg0S z-ObF<&0y^=CJq8OQ`~ul#UGvqrSEnb=D5K$a}yY|Ghv4bhvkip~V8;d`hKBW_EpRp)~YxNExdBbve zQeUJe03?2bV}ni1{n-3jtv?g-AX-GU721Ax&8!12o?n|t$o9Zd+{|XSxQPZ@LeU35 z$cQRUl(y@7YzMgD`G4tTv3LTKX$Lwc(Mj`J|=ZHvJ#8Q z4nS4JUqm#vqXu;D zV}5zNbS$!`|E8=kk~>2s`OadC)9E!FQG{vdf}CQ2ndhAM+0!+3--Y2OE;d1R$A*fBHroA%a12_-C#zG*M3u|b**RE-FF$-X%G#+A+*bIJW5~v z#jyM4)`xQLE@FRA2@F}KhxDqKcxHb{ykl<)nuI+>ex-t|3vMBuHajY|L-50W0cVEf zo=F>Sb(pQw3h_XZbg*Lrj_AB%XS<;K>{hxNja;m&1(;Um#0Ew7<=N{DQ|HLbTvQEHhde9fu2d` zr;_9o5E1IypAnr}C#F4DE-$|7ka%?RiQz*BM*ru+a~`>w9YSn00V-&X6$< zLT!9x*SuKj>N=>l#r%C{Z}w2q*0JIJqs|x6G2D`0ca`h2-xo_RuD#`uG$FEFd(Yj% z9G5_N7VNJ-Lj;H>mg0E!cXvKxgd^3KnB%jS zSxOSs$ppr1LsE=aN+L1#+7hVUW!CIv+DVAk4dQOuBqLp#FP zwQ^*LaCc}E8kkCNAc4_OEW#}AYc5SR+jDjL>L?liTDXIu<%UWXRDb_j1kU%o)~AbzQ=) ztu@p+u7PB0X1^auq=0j8Qxo?H< z(Q%3+S#^7Dy^ioNn%HH9*a{T`Nu*L`HV#fRw~WiiC|%ty7@u?vSb-AtZ?OJl0~81& z#9{%UA`Xx{ng0Q(9{ljd7425X7lSLPAmu?47s0oVy7{E?L^t75-fsJcfDS_Acj0SK z>+Q`mbtf5=0i3gUkk}ebCk$uk=~Em;;mfK7ej>P+?LTtxrHW=21A1&k-5`y+c0WlV z6^JXQ|G|B#Xr5NEah3d6DuIMBYGn9CWOVzeBHCT;w)*EbSuhyEps1r^@aSk8=F+^qW{>Kixl>@xa`J zdjY1wF^5t4Jo;s^@%#KoGPO@bvgNy1UOvT%(-&Obwt|0lYNFC;s>9ogp#W~F_qoB0 zl;kq8ihOVrkzb+Ph6!EU%QfDbYBO7c~NmE2n zr97qMh56eJzU)wq!1u3KXSpJJVRQWs&H+4ttUJ3?W|-EN#pC~^Vh7UH`We0BWN+<~ zu=>4bU+;((%wwjX3gJ5B%S<>iSls4Hs54C9f0Ajcd%nbSdd7{o?K+%O%{Uh8pd$(DG`7_Pbv)xZDEtY2=SV& z@2bWK!8ogUyU`&-?_%^&Ku>^KzgpNH4m6JN=lNwrVTUx4NS^v}+XXV!A8#CR?3pDn zS)Sa-e#d2ioq0Yc{R?hXQ!=q;IUM>t&M#f~+4w3+A!)2p8a@u;jx+DbR}!NhTa+|$ zm$chQe%;vV9aH0U$4V9pB|}Ey_msA3K?(ddV0`~{!r!=`?mzt%f*R~r6)tjDG!r_n z+nVfq6S3Bw&mpm{y@u1Myy71I?9+f9(AbAkJ^6Pe#H2Q?L3!$YJJDE|0a>)ID-+lK zLF0`j!8enl&u-_U?zrlq{b-!f6?mV{Y11I3#7Csy{Z+e1p@{D2kI1gjsu$?DnS4#t ziJ;zmNtp^3tdxGky5+{fQzo&6JImVntOU>NTX$_}^X&6eC8I*+sR5_07#;v}O!5c4 z50C>cCI(PJMbAY4>iUiyMy1lNbsRc>?jO}c_%-j4qseXkLWmkr*t`kiQtlj-i;w$7wdD!)i0S+#rs z?#2iF6`%3+@)5Fb6@!eNc9(5t-GgaAhA0zS_C|9Ht_Rax)o1CO&8-sI9sW8sq1S;C zNa_&Uojeap<*y)pRg5Pqtgw1q-})-W~Khp>u{6q zukj={`8@pe?7pGb)5!Hr{-|xbpMJ#Cg1jt7KR(G+g;P`=wX|))B$Q=G7|+b0nGoa< zQ^4ztXlpi6H#KJl)EE0H`g=ADPf&cK=(`rgWSVt(RG+_&XIb-!I2D)3uskCDcZ9J0Qmch^Rz{_{*DnD31Ylt!uVby2t1Fb*7bF;a&G!G z{p173k&TGPLoS>FM~Vc8mIa5FOpFuw2KEi&irilTB3=SQdoaTAacCouI~k%`xmaSa zW%Z)i57yf9OSzK!GcXu~KM*njr5K)RL7@g5g*UMScb(|bV)VZ2a;6`sn}I3Gb+E9@ zQ5^;MoxEP>g>=;M9O&WDLc-F%_G%ZVr;30@|8&Fk(n5Ce3QpDUAo(OTZ3i;>+A605 zKHuYtS#ZxByWB-CSDKTq$BKn_9_*UQYw#TAwT}IjVH)5aT4K8Td0<#p`2u#%4i?BJ zQ1Q#P{6XeL_r_j!Nozo{%y5r$Ab6uxzm>7!Y}08U*HumpOfN^AgK4GWJuQ0ACHxd| zwW1z*FRcQjWnBxV$Jde-odLX*thXEp9mUR1Bi=WVb`X#Yn5#LAfZwThYKh<7GP4nT z!4kW&ilnARuF7YhP z{PEX$pspZi7L4w=wiK$1_@kZLs%OaD@OM&X(__Y0DP9qZ@aE~Bt~eSqNdDo2>iy=e zB&<3jaBcl{J7-uc*T3h@8Dz4s7fKHzyBwJy&BtKM|N*`zc?MQ{B) zRq6;k;|y%?^HPCmUbB+}E9Jx!6HfKqSzjy(rtP-gRdha@p48+^|GB;2K^;G>uAl0; zY;yL?AzR4$_5MtAv^XKRvWT}^;;a7#5+6THzDLPl?mEna_9OFOTBw)2X4pb zpJ#aS-jGgoRIfnOM-?qqNK|x2hO6o=kPk-Pl!ceTRRf#jHV>*T9n7X`vJ62#KAvV2 zJ-i(lgXa;d)0FI^T=IW`VY;2UV$Q39%@B-k7*AhIcZCus^nLK&=1l1ceQ$z6Pg(E+ zEprb_W{d@v_0ybZ z8R3+b`avyPYv^*$!Ox(kjvxj^zWH<0f4WKY{*iaZh%E}TjQZFOeDyL4%SXtB!8T5y z8b;C0r{-CpSRyN9m&Zh0VRZo+?zL6XRY9qY&XiYOmaLxFnNLuhTeo9Ieoc;*b}k}2 zcr;}69+#zIA9LP%UJYlJBp2i8wxCiB}l!l9PrPpY%o=y^pb6mH6^K5>nbh z=1d7TtGjmibznCIvyouXr6~-T7o-5B03NPp^fFxVIB<_KNku_g#|P?T=9#(=1MvdL zW$j*M0)N>LWsIla5CMNUM?2pFBq~o&q&sqB?Z?nIZClL#;LCzYjwJ~2*}Q;Awb;(kaV=lqGA1P7^hgOILE1ufephfo^OU3Wnp};7P$e zg#4%cMAoRvI5JZ#9*i`htHwF^IlT~>urKN~9wkmjK7US$qY+ZQaaa&Fp3 zc;L#Kd%aJ97W$$zjO8N)A44?~zx(%%dyzd?U2Ivoy}T1X7#HQ-7cYv`X+H!6@HYoMH97e+s^6Zn(4#-ou%B}giI#ao8Di2&+U`}zUlp?uZw`b->BSXq#fH&wV_p8JZw9JK` z;Du97w+73_b(pjon$+w|G;JOYNKEPV!;bWvWdEArBJE@jD}JP}jNxY$zOjjjt0MA7nwXbu8&{Hx&@^C*C-LG$aFeG9ot%hNsv-Rd2d!g>t zS_)4*&tac*v>ZCiw^gx{duyoA{QD_fl?V0|^HIV)#t_2Q*0A6VJ7JE3K+$QfDb;xw zCsg)_$VS`b#N!=pKGl6WC2W$#MSP{ctNi_G*1kJ%UKVvKHc6y^0~M{>Nd)#;reRmp zXl@``_Mra-?}@PUlkQ5qFC-bnou64?B<7D7+Fs>IOBh{@XUX!%vbR=>H)z@_Eviop zZLzAJomgxx!qRYZg{M+pG3n;X!ZQeKHKUbZB&zt$+!xz>$?ekVka{V@>=0S3S2G7nQ`xIm|GMvQ3$Eu4D^E$+q92AQ_ zKYQA4%_>((frKHNinLGQMk1~_UN}j&u)pfv@IH|*Ig>aC+TXX{l#$-VE*S?)}dz4x>A@q6{R z%f2uERqEAgNSb=ZAQ4|DTY!^_C!;*I+`!oaQ9bozt`kyE638UYy zNd%zDj zqv~o8OOpp@S$>oJ8Ei7jw2QwHmu3S+z5P~d9rlD}kVLUNMf^j#Ad+idqb%o#@5fkv zSl%6z239S*McJW#qQ||)l=vPmTJDDH_STE-?O2;1vm1ewocu|h5#K`o13vLjrvUCg zt9sard$netY4UTcY6;)h>+ahuV>P2|H{Et$%eFC=JEvU@;%H;li>th=U8}`gXXsOu zJ{BLlZfaSZRHS{rFm}#5LliDnWq&~WPv@?i&v@_u96FRwUf zD}e_FV%4kANMjr^<~|5a^bl{T>ThPKw3VkLC%)8BGEHi3rBs>fEv0Fzz288u@*~L? zOG3stD0=kL{`8_KfDDBe&50DH23DE4E2sb@QwI z4nsj=z%v!tk#&k&{nC?|^hgLPt7QaMprhV9FfTSpcw&=^!t~4E!`d#!>-$Dr7N8m| zGb%U!^T@&5lUqvQRG{BoXOIkL2pc?BW#%T7`xS{7^wAhM5rY1T zq=5o*H*nqFVyjcIa{y*1BP!b^@a8zk#3*WfBvLj;ybc&p> zBVYC_AO7`*8eIID4PI60Qw6mSjoGrr&$h>pFRGVnMFkf}vH{IC&Z@g-+UcM-tHLhh zKXb#2W0gS~1qA3>k^V_zjX=|{Pi%n*P7xeJaUnK7G|UQ;z)2Pdu{l8sTd;N zz2&@bIKq-pT^4{hW{(!H=i?v-RwjS^nG6cz{sDpu4u1_RCH6i@%WFK|6T;$OUOxZU z*}`OKVDL~OQw@Rkt=|oG;@#y!(*~|{p4t61arL+ees#V= zg;pXHe_kCvox0W2AKD7i1_M=l#3;o}FX<$= zPp^pyl~JDN`^2zZV@jMua}@YK>P0i;dMy_1i1}8rCa!h0BIuN0boptXAW6fXE1ewa zj%lrR-scUc@efVLi4U!vOLq*<;9`c*@X5^`Lb(&N*?Yus&5V5ZGvGy;oKKGTFLe3N zon=YY2A26kD90Dm?zhq$Zjtjsxx*7mZs%_OZpRw-E-o%10}?!Oi0_bVOJ#BlLOiWP zR;AP-Nm9O-&(pN<8PY>cY!!%!YJbwjhax*Aeq?+?+k^WfnR)}F%%`UR-;y#qfyi1B6vln*Q8K1vU&%&^=R#nMsvQ0-}_>&QRKLH;MoQYx{HsPU)46-Zhy&m=YBUhqk^4z*nK=P zRQ8RN?M7nRm5+Zc?g=;0Png4h~+CpR3N|TW-^TDuaw0SPkX$Z2+4oZ;RECRAzpt>jtbfc>;#AJMp{snuOS{7G>) z?*95|m#M>n7%*j!7n#k4Qea3P)R5Z9-0UxrD@`b)P3s%O{&-TA?3u-N=s zSj1$=LT}@sD5BPV`ywoMigyXWYL+DKtn4zBd&}GXc!zTKo@MUDc2D-bdQTundzEo=& z?qWRF;>k(pu@4<Z_G8T(?v=#ViFpEAJ zPMEJA3nvB99K6F0gM7lPMUXuqQLU$#te{`;Q$CX*HMjoW!S6)XYWP^IjbWIA@a)T5 zXeZVDc4^&njTG1SmF<{S!BMhHu`+Z&Jcw1)NE(`Z6p!6C(9be(3jl#Xfem5w?w!nX zmV<#73in7oB#M4wJg*6R-#KB+c%euh{Yckx{}^jEj*q|maNI0(D0UFEt2@%sHQO6DaJ$ zz!w=T!$f^WCX(x?D4ZV2?3B<^z_5~yXA~H1r!Kssl8#F2Q|6Oo9A)L1s{ufZP|OPS zjDs9Obswy@34<%FXI3}YumktKunGmK4$n`ZsV*F3N^(MfxGZ+NXeZZ!6?V@=Uom5s)T3=^JHa7ygmF`E zA&2A~lb&b(#~yUIG3)6ojJS&}78n8XwEGllFl88hE1c!08nB1sEjH+;sYK%`D{In~ zeCH|3R=c2|K9@cG*9!xfPheB-M@m$h#=`4=?o%(3sSYl0d#V^&!ZlgzMc?6lBh$r3Vk6HHH->p4CGV(@^Rp-wMoeQgJuJelwJGW>!=a?1q~WJDjk+FU zCdb9R@FAY(q72CzS{j8(SeXa3Ia+ehgPvP~M#bbIg%Qd&6V4~U#LVu3rh%Y>XnS{vvB+F`NZkj z26z;+%%suD-UKEEYtSe0aw#l?;M+vJ<^cvK7;D2kBFU@T#|a#W_FB}po-Rfd_TOw0 zE}VYgVbr6uu$frEJij8ST_h3P{WbIHQ3B6BHjLKb2NvxkCKLShkM>(=1Bn=t8a8a& z&H7qDDsamo$;7L{KtcRoP|hX05oZ{Cs8Mk22jq7`_-&=SDa3rMzLc#Qkc$D>;cPv# zus<>k=QlE5YT!VZL~SPE=Q+a;w7fV{v9$91@uP$Igj|DuSWNX(sMdkbNA7ACuGH_h zoff{&?hK0{!}4{N{Z2FK<@Pb`@O4``((FP9ge)Spj!hLdqs}5>!2+;0{I*Ic-+l?; zhDDeWwl-nkzQKrmOKkMbA$x!rR4y7LwW-dM{d`Z$B+@H5tS!@6e%OGr!E<9Ihv(8g zZRAq5bbvGJ*x%GWo;%8=ZKd>8$v$|LIrI6vK~a0P9tv)3_JF_R59V9@V#lWY^iJwZ zouIt|+|0I^!bCjWR^uKHTV*;1bGb2n#}37dM6B_M9CNHHK#HP-`R!f(b9pnl-IDdB z_9C9dQV~F>ye7=nQo12@;kJp*%3M&G!^(PxHg*?P^+j&4p-b~MG>a?~GGo{HbN}i) zxSe_b8Bm|4V$!5b(j~E%oj8YIbCmTr&9s5t>X89y72!vsJvjiYnbFCh3#r(VowwGM zftyKOTq%t&S-x<8bum!a9n~9Gc4D{?SNNHItS0}mb#sqT>Pl`vr%C&` z5R-^?qvMWT8$vrEf=kKdB2vvA-W)`?3$*|OOU#>$ z19vlj-r4U#1HJ7Uma9p{ax-&p=T$DDiQX4rGr@b!)pI*JOw0e(+qJ(#y{&P!%Nfix zI}Lt+hruicKZ&Q3XObKLl+}W3}GT^ z52JA@mzeC?oxPvu`~~NiwboDXTF+YReb?u+p67i(K2HoEJ2`%)QYeok@smQK93Xni z*77;9@ucdm4zJ$nXg+_ri$Utxli<6t!8cZ*u70r8tX0tVr1hk^5f4s#~?71lW zsYG6Vi_U|3lFh~3iN?L^Y`iDgXsSMs0YKwWsQn~jT_askQK9u7g zb6bT;>UbY4Pcu}pNvXR-QtEd| z3#rQovL0={*j%Ki^H~%cbrHJG-Nw-fR;l@53CuF4Q`zhh(I-c9*14zZ;iap+YYw;w zhePwnDYik-j3kqOV*Oxpy7g?e(wxi}`mx+P)CHMqeli8%rC+UdepgyMZ7j69-THJs zMI|b(q)qF@E}D;1PIP^n;AY z_6X+Cy}?3U@6w?Hg_eJR=>9FiZYnv$&5IYWYE$r{2o^{;+3L7%!$MGXj&I!# zyYxm&1tZN*Y`zd{iqNtrICU=j!EFcEYn;T(Bj<)4gLCw#mITp9lo0o@uazv_CO!Tl z8(39csy?FQ(TyhE);7^n+ROw5s!MoLpQgvA_{cjsjQ4%ufC2G4dDJENd`Yf2dCr@D zCc-xi$8*Xfi>bj$@SYDU4__Q?ejRGJo88RRHcB;LZlEMfN*It{p)S?}Dx17UL4L<~a0E+GMbw>Vx}Up8o=7O3}1!{nebZ293M18@qhRCLv+lFU?UhN(B&jS2jPY=4E%=#Ct%i4}qd1gooHkDkB>`=i`=S#e3b%49Hf zZ9+^6k0L!~&I!m>wt@MWc}HivNQfI%9z)k4@SnvYicsw1btc4>sg-$?lLHRDSS?wa z1-az=O3vpq*6i8v$9E%jjfid-vw)3B-QqU6G+#J~caUg_=zXiNSoYwNGmj-Ew7f4y zW&`gUe|)$yhS7kCOD}&mK-}x>?3{>*F&3@{%9Vdo79hu&@TJ63vhceznWU=m`>f?+ zrZ^1pG=s%rm2@Q=3vb}@V^$jxhn{Jhik!3URETX>*OV5jXwM-?A(#4`;l3L&K3kw` z&AMOs>xo)$}(?LxBqqrQJstoh;rbOeIfOxv6-QIW(vvi z0e67#VO<@&-d~(|R?0BK`my3|J^^_yOoRWW5jjSW=`-g--6JB%lXd$aY99JXYuypL z!C)T8AqemX_J!5g8p6WWv8;18S2=d_DmGX!6J>YQJHIs!(G(C!*Gz-he+y&livGCb z8lu?K=&ps8FEsgvf3+{zSgrqdVjd9b`t{T4xiqZpf=s4x8O>G1kn4-n66%F0;phmW zKVFafEe9AMPJxjU)*23iUqJOY=qSD+`|fj+(Q0vq!~{%8(-L?q6v6Fs%!6 zd`RE!x)x!vBJb_`Zrl#&kR{h5Lvpm&0BG!oB`GRf znxY?Ut}sw|4`~az9kg|?fb`OFj25R(@N2@iA2UBI-jY#I!%OZqzej(KuM$JhU!I8w zC^Hu}c7-|&3*F@$VuQ&+UO3*}m=J$=<%;%Cac22|fbu*F^f}vU#4R5Ei2$KoD280J zE9!NODOPrLa#CaUEgQOTKW}$Ir}FYZVW*`n_19j^Sp<&P%@UclCI6^fp1Gt#h`rnm zjk4GJiPGrGX%Ov4PvSqJh_*Grp?Bt~O!$mPdpsWQ0#nBE>>xvyRjCP_MHaad#Mj&- zhTBD*mw>9dU(i?tA-2cvd(uSmc0NZ;O3nqcj6k1p_Vupo&E=`3MVE9s^rLbNKzX?} zpf*IqmZ1N_xiT~8C~uu{SMbGNJ#Ww+%~ioj@Xy+vQL;B$=*vqE1golfSChgi6D^`W z@ZLzexnyH)!ToxGce^7ULzltv`p}WNB@9WS z?^C0AsMk9yu&Ohvt$8|sToCeN*iaJs)*9`16&C|*sUGHPr0KB=@<5jMy5%( zQimn}RW#$MKrIFy!PiD$MidxE|q5 zr602ciXAlopMO@}{q_Ep0E(^XayC!PCM|1HQ23H`A}PpHVmO?&m<(682oky(9wZ7% znHjH3NPE<#5z6uJVnEi2@MH6TQlcA+0l!(tQY3dfQUXB2tmz=G0RqdD*hbzzT4%qo zP8lqxNRFh;sS-tWD@w_e?Clha2m`CI(TQ2pdxx{B&SQ;=0kn?Ix@rW%1L_5UDMYv@POmOr(fW;7ktWz1Qc0W7hUH0edR#PogPZL;wH) diff --git a/Packages/JSX/screenshots/compare-jsx-illegal@2x.png b/Packages/JSX/screenshots/compare-jsx-illegal@2x.png deleted file mode 100644 index ac8931f199a72e9e1d8f14ab7aed728cf9953cb2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 30862 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 diff --git a/Packages/JSX/screenshots/compare-jsx-tight@2x.png b/Packages/JSX/screenshots/compare-jsx-tight@2x.png deleted file mode 100644 index 9aa4a2e6b60f52660a72f2f18bbaa06c1448bf77..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 24980 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ℑ3yc@O1e`_ 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 Y&FLg{f3Be$+rXcZfvJA+1*eGr0Ye*sJpcdz diff --git a/Packages/JSX/screenshots/oceanic-next.png b/Packages/JSX/screenshots/oceanic-next.png deleted file mode 100644 index 4256f528c486cef1e941785af5da17eb863b4b70..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 59838 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
$yz`u$*^si9K%&D2TDEm&=~ur& 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 DQvHLB diff --git a/Packages/JSX/test/syntax_test_issues_OLD.js b/Packages/JSX/test/syntax_test_issues_OLD.js deleted file mode 100644 index 8b3a41a..0000000 --- a/Packages/JSX/test/syntax_test_issues_OLD.js +++ /dev/null @@ -1,275 +0,0 @@ -// SYNTAX TEST "Packages/babel-sublime/JavaScript (Babel).tmLanguage" - -/** - * https://github.com/babel/babel-sublime/issues/243 - */ - -class Foo extends create('Bar') {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class -//^^^ meta.class storage.type.class -// ^^^ meta.class entity.name.class -// ^^^^^^^^^^^^^^^^^^^^^^ meta.class meta.class.extends -// ^^^^^^^ meta.class meta.class.extends storage.type.extends -// ^^^^^^^^^^^^^ meta.class meta.class.extends meta.method -// ^^^^^^ meta.class meta.class.extends meta.method string.unquoted entity.name.function -// ^ meta.class meta.class.extends meta.method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class.extends meta.method variable.parameter.function -// ^ meta.class meta.class.extends meta.method punctuation.definition.parameters.end -// ^ meta.class meta.brace.curly.begin -// ^ meta.class meta.brace.curly.end - - -/** - * https://github.com/babel/babel-sublime/issues/244 - */ - -var foo = bar ? "+" + baz : qux; -//^ storage.type -//<- source.js -// ^^^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^^^ variable.other.readwrite -// ^ keyword.operator.ternary -// ^^^ string.quoted -// ^ string.quoted punctuation.definition.string.begin -// ^ string.quoted punctuation.definition.string.end -// ^ keyword.operator.arithmetic -// ^^^^^ constant.other.object.key -// ^^^ constant.other.object.key string.unquoted.label -// ^ constant.other.object.key punctuation.separator.key-value -// ^^^ variable.other.readwrite -// ^ punctuation.terminator.statement - -var foo = bar ? "+" + baz + baz2 : qux; -//^ storage.type -//<- source.js -// ^^^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^^^ variable.other.readwrite -// ^ keyword.operator.ternary -// ^^^ string.quoted -// ^ string.quoted punctuation.definition.string.begin -// ^ string.quoted punctuation.definition.string.end -// ^ keyword.operator.arithmetic -// ^^^ variable.other.readwrite -// ^ keyword.operator.arithmetic -// ^^^^^^ constant.other.object.key -// ^^^^ constant.other.object.key string.unquoted.label -// ^ constant.other.object.key punctuation.separator.key-value -// ^^^ variable.other.readwrite -// ^ punctuation.terminator.statement - -var foo = bar ? "+" + (baz) : qux; -//^ storage.type -//<- source.js -// ^^^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^^^ variable.other.readwrite -// ^ keyword.operator.ternary -// ^^^ string.quoted -// ^ string.quoted punctuation.definition.string.begin -// ^ string.quoted punctuation.definition.string.end -// ^ keyword.operator.arithmetic -// ^ meta.group.braces.round meta.brace.round.begin -// ^^^ meta.group.braces.round variable.other.readwrite -// ^ meta.group.braces.round meta.brace.round.end -// ^ punctuation.separator.key-value -// ^^^ variable.other.readwrite -// ^ punctuation.terminator.statement - - -/** - * https://github.com/babel/babel-sublime/issues/249 - */ - -{{{{{{{{{{{{{{ -//^^^^^^^^^^^^ meta.tag.mustache - console.log -//^^^^^^^^^^^^ meta.tag.mustache -}}}}}}}}}}}}}} -//^^^^^^^^^^^^ source.js - meta.tag.mustache - - -/** - * https://github.com/babel/babel-sublime/issues/253 - */ - -for(let a of list) -//^^^^^^^^^^^^^^^^ meta.for -//^ keyword.control.loop -// ^ meta.brace.round.begin -// ^^^ storage.type -// ^ variable.other.readwrite -// ^^ keyword.operator -// ^^^^ variable.other.readwrite -// ^ meta.for meta.brace.round.end - -for(let a of []) -//^^^^^^^^^^^^^^ meta.for -//^ keyword.control.loop -// ^ meta.brace.round.begin -// ^^^ storage.type -// ^ variable.other.readwrite -// ^^ keyword.operator -// ^ meta.group.braces.square meta.brace.square.begin -// ^ meta.group.braces.square meta.brace.square.end -// ^ meta.brace.round.end - -for(let a of (list || [])) -//^^^^^^^^^^^^^^^^^^^^^^^^ meta.for -//^ keyword.control.loop -//<- source.js -// ^ meta.brace.round.begin -// ^^^ storage.type -// ^ variable.other.readwrite -// ^^^ meta.function-call.with-arguments -// ^^ meta.function-call.with-arguments variable.function -// ^^^^^^^^^^^^ meta.group.braces.round -// ^ meta.group.braces.round meta.brace.round.begin -// ^^^^ meta.group.braces.round variable.other.readwrite -// ^^ meta.group.braces.round keyword.operator.logical -// ^ meta.group.braces.round meta.group.braces.square meta.brace.square.begin -// ^ meta.group.braces.round meta.group.braces.square meta.brace.square.end -// ^^ meta.brace.round.end -// ^ meta.group.braces.round meta.brace.round.end - - -/** - * https://github.com/babel/babel-sublime/issues/256 - */ - -return a ? a*a : 0; -//^^^^ keyword.control.flow -//<- source.js -// ^ variable.other.readwrite -// ^ keyword.operator.ternary -// ^ variable.other.readwrite -// ^ keyword.operator.arithmetic -// ^^^ constant.other.object.key -// ^ constant.other.object.key string.unquoted.label -// ^ constant.other.object.key punctuation.separator.key-value -// ^ constant.numeric -// ^ punctuation.terminator.statement - - -/** - * https://github.com/babel/babel-sublime/issues/270 - */ - -class Foo { -//^^^ meta.class storage.type.class -// ^^^ meta.class entity.name.class -// ^ meta.class meta.brace.curly.begin - bar = baz::map( -//^^^ meta.class.property variable.other.property -// ^ meta.class.property keyword.operator.assignment -// ^^^ meta.class.property variable.other.readwrite -// ^ meta.class.property meta.flowtype.annotation keyword.operator.flowtype.annotation -// ^ meta.class.property meta.flowtype.annotation keyword.operator.flowtype.other -// ^^^ meta.class.property meta.flowtype.annotation variable.other.flowtype -// ^ meta.class.property meta.flowtype.annotation punctuation.section.flowtype.begin - thing => 1 -// ^^^^^ meta.class.property meta.flowtype.annotation variable.other.flowtype -// ^^ meta.class.property meta.flowtype.annotation meta.flowtype.function keyword.operator.flowtype - ); - constructor() {} -//^^^^^^^^^^^ meta.class.property meta.flowtype.annotation meta.flowtype.function variable.other.flowtype -// ^ meta.class.property meta.flowtype.annotation punctuation.section.flowtype.begin -// ^ meta.class.property meta.flowtype.annotation punctuation.section.flowtype.end -} -))} /* END ERROR */ - - -/** - * https://github.com/babel/babel-sublime/issues/274 - */ - -void
{[]}
-//^^ keyword.operator -//<- source.js -// ^ keyword.operator.relational -// ^^^ variable.other.readwrite -// ^ keyword.operator.relational -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^^^^^ meta.group.braces.curly meta.group.braces.square meta.jsx -// ^ meta.group.braces.curly meta.group.braces.square meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.jsx meta.tag entity.name.tag -// ^^ meta.group.braces.curly meta.group.braces.square meta.jsx meta.tag punctuation.definition.tag.end -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly meta.brace.curly.end -// ^ keyword.operator.relational -// ^^^^^^ string.regexp -// ^ string.regexp punctuation.definition.string.begin -/ /* END ERROR */ - - -/** - * https://github.com/babel/babel-sublime/issues/275 - */ - -if (_.startsWith(line, 'State(')) {} -//<- keyword.control.conditional -// ^ meta.group.braces.round meta.brace.round.begin -// ^ meta.group.braces.round variable.other.object variable.other.object -// ^ meta.group.braces.round keyword.operator.accessor -// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.round meta.method -// ^^^^^^^^^^ meta.group.braces.round meta.method string.unquoted entity.name.function -// ^ meta.group.braces.round meta.method punctuation.definition.parameters.begin -// ^^^^ meta.group.braces.round meta.method variable.parameter.function -// ^ meta.group.braces.round meta.method punctuation.separator.parameter.function -// ^^^^^ meta.group.braces.round meta.method variable.parameter.function -// ^ meta.group.braces.round meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.round meta.brace.round.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - - -/** - * https://github.com/babel/babel-sublime/issues/284 - */ - -@web.controller('/hello') -//^ tag.decorator entity.name.tag -//<- tag.decorator punctuation.definition.tag -// ^ keyword.operator.accessor -// ^^^^^^^^^^ meta.function-call.method.with-arguments variable.function -// ^ meta.group.braces.round meta.brace.round.begin -// ^^^^^^^^ meta.group.braces.round string.quoted -// ^ meta.group.braces.round string.quoted punctuation.definition.string.begin -// ^ meta.group.braces.round string.quoted punctuation.definition.string.end -// ^ meta.group.braces.round meta.brace.round.end -class Klass { -//^^^ storage.type.class -// ^^^^^ entity.name.class -// ^ meta.brace.curly.begin - @web.get() -//^ tag.decorator punctuation.definition.tag -// ^^^ tag.decorator entity.name.tag -// ^^^ meta.class-method string.unquoted entity.name.function -// ^ meta.class-method punctuation.definition.parameters.begin -// ^ meta.class-method punctuation.definition.parameters.end - foo(a, b) {} -// ^ meta.class-method punctuation.definition.parameters.begin -// ^ meta.class-method variable.parameter.function -// ^ meta.class-method punctuation.separator.parameter.function -// ^ meta.class-method variable.parameter.function -// ^ meta.class-method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - - @web.use -//^ tag.decorator punctuation.definition.tag -// ^^^ tag.decorator entity.name.tag - bar(c, d) {} -//^^^^^^^^^ meta.class-method -//^^^ meta.class-method string.unquoted entity.name.function -// ^ meta.class-method punctuation.definition.parameters.begin -// ^ meta.class-method variable.parameter.function -// ^ meta.class-method punctuation.separator.parameter.function -// ^ meta.class-method variable.parameter.function -// ^ meta.class-method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -} -//<- meta.class meta.brace.curly.end diff --git a/Packages/JSX/test/syntax_test_js_babel_OLD.js b/Packages/JSX/test/syntax_test_js_babel_OLD.js deleted file mode 100644 index eb32dd2..0000000 --- a/Packages/JSX/test/syntax_test_js_babel_OLD.js +++ /dev/null @@ -1,3187 +0,0 @@ -// SYNTAX TEST "Packages/babel-sublime/JavaScript (Babel).tmLanguage" - -class MyClass { -//^^^ meta.class storage.type.class -// ^^^^^^^ meta.class entity.name.class -// ^ meta.class meta.brace.curly.begin - - type: string; -//^^^^ meta.class meta.class.property variable.other.property -// ^^^^^^^^ meta.class meta.class.property meta.flowtype.annotation -// ^ meta.class meta.class.property meta.flowtype.annotation keyword.operator.flowtype.annotation -// ^^^^^^ meta.class meta.class.property meta.flowtype.annotation constant.other.primitve.flowtype - - type: () => void; -//^^^^ meta.class meta.class.property variable.other.property -// ^^^^^^^^^^^^ meta.class meta.class.property meta.flowtype.annotation -// ^ meta.class meta.class.property meta.flowtype.annotation keyword.operator.flowtype.annotation -// ^ meta.class meta.class.property meta.flowtype.annotation punctuation.section.flowtype.begin -// ^ meta.class meta.class.property meta.flowtype.annotation punctuation.section.flowtype.end -// ^^^^^^^ meta.class meta.class.property meta.flowtype.annotation meta.flowtype.function -// ^^ meta.class meta.class.property meta.flowtype.annotation meta.flowtype.function keyword.operator.flowtype -// ^^^^ meta.class meta.class.property meta.flowtype.annotation meta.flowtype.function constant.other.primitve.flowtype - - @@iterator(): Iterator<[K, V]>; -//^^^^^^^^^^ meta.class meta.short-method.flowtype keyword.operator.flowtype -// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.begin -// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.end -// ^^^^^^^^^^^^^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation -// ^^^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype -// ^^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.begin -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype -// ^^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.end - - static (o: ?void): {[key: any]: any}; -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class meta.short-method.flowtype -//^^^^^^ meta.class meta.short-method.flowtype keyword.operator.flowtype -// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.begin -// ^ meta.class meta.short-method.flowtype variable.parameter.function -// ^^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.other -// ^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation constant.other.primitve.flowtype -// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.end -// ^^^^^^^^^^^^^^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation -// ^^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.begin -// ^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.other -// ^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation constant.other.primitve.flowtype -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.end -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.other -// ^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation constant.other.primitve.flowtype -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.end - - return(value: R): { done: true, value: R }; -//^^^^^^ meta.class meta.short-method.flowtype keyword.operator.flowtype -// ^ meta.class meta.short-method.flowtype meta.flowtype.polymorph punctuation.section.flowtype.begin -// ^ meta.class meta.short-method.flowtype meta.flowtype.polymorph variable.other.flowtype -// ^ meta.class meta.short-method.flowtype meta.flowtype.polymorph punctuation.section.flowtype.end -// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.begin -// ^^^^^ meta.class meta.short-method.flowtype variable.parameter.function -// ^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype -// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.end -// ^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.begin -// ^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.other -// ^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype -// ^^^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.other -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation punctuation.section.flowtype.end - - (o: T): T; -//^^^^^^^^^^^^^^^^^^^^ meta.class meta.short-method.flowtype -//^^^^^^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.polymorph -//^ meta.class meta.short-method.flowtype meta.flowtype.polymorph punctuation.section.flowtype.begin -// ^ meta.class meta.short-method.flowtype meta.flowtype.polymorph variable.other.flowtype -// ^ meta.class meta.short-method.flowtype meta.flowtype.polymorph keyword.operator.flowtype.other -// ^^^^^^ meta.class meta.short-method.flowtype meta.flowtype.polymorph support.class.builtin -// ^ meta.class meta.short-method.flowtype meta.flowtype.polymorph punctuation.section.flowtype.end -// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.begin -// ^ meta.class meta.short-method.flowtype variable.parameter.function -// ^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype -// ^ meta.class meta.short-method.flowtype punctuation.definition.parameters.end -// ^^^ meta.class meta.short-method.flowtype meta.flowtype.annotation -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation keyword.operator.flowtype.annotation -// ^ meta.class meta.short-method.flowtype meta.flowtype.annotation variable.other.flowtype - - regularMethod() {} -//^^^^^^^^^^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - - *generatorMethod() {} -//^ meta.class keyword.generator.asterisk -// ^^^^^^^^^^^^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - - static staticRegularMethod() {} -//^^^^^^ meta.class storage.modifier -// ^^^^^^^^^^^^^^^^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - - static get staticGetterMethod() {} -//^^^^^^ meta.class storage.modifier -// ^^^^ meta.class meta.class-accessor storage.type -// ^^^^^^^^^^^^^^^^^^ meta.class meta.class-accessor string.unquoted entity.name.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin -// ^ meta.class meta.class-accessor punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - - static set staticSetterMethod(arg) {} -//^^^^^^ meta.class storage.modifier -// ^^^^ meta.class meta.class-accessor storage.type -// ^^^^^^^^^^^^^^^^^^ meta.class meta.class-accessor string.unquoted entity.name.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-accessor variable.parameter.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - - static *staticGeneratorMethod() {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class keyword.generator.asterisk -// ^^^^^^^^^^^^^^^^^^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static async staticAsyncMethod() {} -//^^^^^^ meta.class storage.modifier -// ^^^^^ meta.class storage.type -// ^^^^^^^^^^^^^^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - - async asyncMethod() {} -//^^^^^ meta.class storage.type -// ^^^^^^^^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - [computedMethod()]() {} -//^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^^^^^^^^^^^ meta.class meta.group.braces.square meta.function-call.without-arguments variable.function -// ^^ meta.class meta.group.braces.square meta.function-call.without-arguments meta.group.braces.round.function.arguments -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - ["computedString"]() {} -//^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^^^^^^^^^^^^^ meta.class meta.group.braces.square string.quoted -// ^ meta.class meta.group.braces.square string.quoted punctuation.definition.string.begin -// ^ meta.class meta.group.braces.square string.quoted punctuation.definition.string.end -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - - ["computed" + "String"]() {} -//^^^^^^^^^^^^^^^^^^^^^^^ meta.class meta.group.braces.square -//^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^^^^^^^ meta.class meta.group.braces.square string.quoted -// ^ meta.class meta.group.braces.square string.quoted punctuation.definition.string.begin -// ^ meta.class meta.group.braces.square string.quoted punctuation.definition.string.end -// ^ meta.class meta.group.braces.square keyword.operator.arithmetic -// ^^^^^^^^ meta.class meta.group.braces.square string.quoted -// ^ meta.class meta.group.braces.square string.quoted punctuation.definition.string.begin -// ^ meta.class meta.group.braces.square string.quoted punctuation.definition.string.end -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - - *[Symbol.iterator]() {} -//^ meta.class keyword.generator.asterisk -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^^^ meta.class meta.group.braces.square support.class.builtin -// ^ meta.class meta.group.braces.square keyword.operator.accessor -// ^^^^^^^^ meta.class meta.group.braces.square meta.property.object variable.other.property -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end -} - - - -let Sound = { -//^ storage.type -//<- source.js -// ^^^^^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^ meta.group.braces.curly meta.brace.curly.begin - - get() {}, -//^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - get(arg) {}, -//^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.method variable.parameter.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - set() {}, -//^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - set(arg) {}, -//^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.method variable.parameter.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play() {}, -//^^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play(arg) {}, -//^^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.method variable.parameter.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - 'play'() {}, -//^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - 'play'(arg) {}, -//^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.method variable.parameter.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - *play() {}, -//^ meta.group.braces.curly meta.method keyword.generator.asterisk -// ^^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - *play(arg) {}, -//^ meta.group.braces.curly meta.method keyword.generator.asterisk -// ^^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.method variable.parameter.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - async play() {}, -//^^^^^^^^^^^^ meta.group.braces.curly meta.method -//^^^^^ meta.group.braces.curly meta.method storage.type -// ^^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - async play(arg) {}, -//^^^^^^^^^^^^^^^ meta.group.braces.curly meta.method -//^^^^^ meta.group.braces.curly meta.method storage.type -// ^^^^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.method variable.parameter.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - get play() {}, -//^^^^^^^^^^ meta.group.braces.curly meta.accessor -//^^^ meta.group.braces.curly meta.accessor storage.type.accessor -// ^^^^ meta.group.braces.curly meta.accessor entity.name.accessor -// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - set play(arg) {}, -//^^^^^^^^^^^^^ meta.group.braces.curly meta.accessor -//^^^ meta.group.braces.curly meta.accessor storage.type.accessor -// ^^^^ meta.group.braces.curly meta.accessor entity.name.accessor -// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.accessor variable.parameter.function -// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - *'play'() {}, -//^ meta.group.braces.curly meta.method keyword.generator.asterisk -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - *'play'(arg) {}, -//^ meta.group.braces.curly meta.method keyword.generator.asterisk -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.method variable.parameter.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - async 'play'() {}, -//^^^^^^^^^^^^^^ meta.group.braces.curly meta.method -//^^^^^ meta.group.braces.curly meta.method storage.type -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - async 'play'(arg) {}, -//^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.method -//^^^^^ meta.group.braces.curly meta.method storage.type -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.method variable.parameter.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - get 'play'() {}, -//^^^ meta.group.braces.curly variable.other.readwrite -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - set 'play'(arg) {}, -//^^^ meta.group.braces.curly variable.other.readwrite -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.method string.quoted entity.name.function -// ^ meta.group.braces.curly meta.method string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.method variable.parameter.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [Play.name()]() {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class -// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function -// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [Play.name()[]](arg) {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class -// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function -// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments -// ^ meta.group.braces.curly meta.group.braces.square meta.group.braces.square meta.brace.square.begin -// ^^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly meta.group.braces.square meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin -// ^^^ meta.group.braces.curly meta.group.braces.round variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - *[Play.name()]() {}, -//^ meta.group.braces.curly keyword.operator.arithmetic -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class -// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function -// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - *[Play.name()](arg) {}, -//^ meta.group.braces.curly keyword.operator.arithmetic -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class -// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function -// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin -// ^^^ meta.group.braces.curly meta.group.braces.round variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - async [Play.name()]() {}, -//^^^^^^ meta.group.braces.curly variable.other.object -//^^^^^ meta.group.braces.curly variable.other.object variable.other.object -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class -// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function -// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - async [Play.name()](arg) {}, -//^^^^^^ meta.group.braces.curly variable.other.object -//^^^^^ meta.group.braces.curly variable.other.object variable.other.object -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class -// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function -// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin -// ^^^ meta.group.braces.curly meta.group.braces.round variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - get [Play.name()]() {}, -//^^^^ meta.group.braces.curly variable.other.object -//^^^ meta.group.braces.curly variable.other.object variable.other.object -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class -// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function -// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - set [Play.name()](arg) {}, -//^^^^ meta.group.braces.curly variable.other.object -//^^^ meta.group.braces.curly variable.other.object variable.other.object -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.other.class -// ^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments keyword.operator.accessor -// ^^^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments variable.function -// ^^ meta.group.braces.curly meta.group.braces.square meta.function-call.static.without-arguments meta.group.braces.round.function.arguments -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin -// ^^^ meta.group.braces.curly meta.group.braces.round variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - 0() {}, -//^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - 0(arg) {}, -//^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.method variable.parameter.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - *0() {}, -//^ meta.group.braces.curly meta.method keyword.generator.asterisk -// ^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - *0(arg) {}, -//^ meta.group.braces.curly meta.method keyword.generator.asterisk -// ^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.method variable.parameter.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - async 0() {}, -//^^^^^^^^^ meta.group.braces.curly meta.method -//^^^^^ meta.group.braces.curly meta.method storage.type -// ^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - async 0(arg) {}, -//^^^^^^^^^^^^ meta.group.braces.curly meta.method -//^^^^^ meta.group.braces.curly meta.method storage.type -// ^ meta.group.braces.curly meta.method string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.method variable.parameter.function -// ^ meta.group.braces.curly meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - get 0() {}, -//^^^^^^^ meta.group.braces.curly meta.accessor -//^^^ meta.group.braces.curly meta.accessor storage.type.accessor -// ^ meta.group.braces.curly meta.accessor entity.name.accessor -// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - set 0(arg) {}, -//^^^^^^^^^^ meta.group.braces.curly meta.accessor -//^^^ meta.group.braces.curly meta.accessor storage.type.accessor -// ^ meta.group.braces.curly meta.accessor entity.name.accessor -// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.accessor variable.parameter.function -// ^ meta.group.braces.curly meta.accessor punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: function() {}, -//^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: function(arg) {}, -//^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: function*() {}, -//^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: function*(arg) {}, -//^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: async function() {}, -//^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json storage.type -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: async function(arg) {}, -//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json storage.type -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: async function*() {}, -//^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json storage.type -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: async function*(arg) {}, -//^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^^^^ meta.group.braces.curly meta.function.json string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json storage.type -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: async () => {}, -//^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow -//^^^^ meta.group.braces.curly meta.function.json.arrow string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json.arrow storage.type -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end -// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: async (arg) => {}, -//^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow -//^^^^ meta.group.braces.curly meta.function.json.arrow string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json.arrow storage.type -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end -// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: async arg => {}, -//^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow -//^^^^ meta.group.braces.curly meta.function.json.arrow string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json.arrow storage.type -// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function -// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: () => {}, -//^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow -//^^^^ meta.group.braces.curly meta.function.json.arrow string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end -// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: (arg) => {}, -//^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow -//^^^^ meta.group.braces.curly meta.function.json.arrow string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end -// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - play: arg => {}, -//^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow -//^^^^ meta.group.braces.curly meta.function.json.arrow string.unquoted entity.name.function -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value -// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function -// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": function() {}, -//^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": function(arg) {}, -//^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": function*() {}, -//^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": function*(arg) {}, -//^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": async function() {}, -//^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json storage.type -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": async function(arg) {}, -//^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json storage.type -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": async function*() {}, -//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json storage.type -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": async function*(arg) {}, -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json -//^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json storage.type -// ^^^^^^^^ meta.group.braces.curly meta.function.json storage.type.function -// ^ meta.group.braces.curly meta.function.json keyword.generator.asterisk -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.json variable.parameter.function -// ^ meta.group.braces.curly meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": async () => {}, -//^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow -//^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json.arrow string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json.arrow storage.type -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end -// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": async (arg) => {}, -//^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow -//^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json.arrow string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json.arrow storage.type -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end -// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": async arg => {}, -//^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow -//^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json.arrow string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.json.arrow storage.type -// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function -// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": () => {}, -//^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow -//^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json.arrow string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end -// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": (arg) => {}, -//^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow -//^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json.arrow string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.definition.parameters.end -// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - "play": arg => {}, -//^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.json.arrow -//^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.begin -// ^^^^ meta.group.braces.curly meta.function.json.arrow string.quoted entity.name.function -// ^ meta.group.braces.curly meta.function.json.arrow string.quoted punctuation.definition.string.end -// ^ meta.group.braces.curly meta.function.json.arrow punctuation.separator.key-value -// ^^^ meta.group.braces.curly meta.function.json.arrow variable.parameter.function -// ^^ meta.group.braces.curly meta.function.json.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: function() {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: function(arg) {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function variable.parameter.function -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: function*() {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function -// ^ meta.group.braces.curly meta.function keyword.generator.asterisk -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: function*(arg) {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function -// ^ meta.group.braces.curly meta.function keyword.generator.asterisk -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function variable.parameter.function -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: async function() {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function -// ^^^^^ meta.group.braces.curly meta.function storage.type -// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: async function(arg) {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function -// ^^^^^ meta.group.braces.curly meta.function storage.type -// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function variable.parameter.function -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: async function*() {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function -// ^^^^^ meta.group.braces.curly meta.function storage.type -// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function -// ^ meta.group.braces.curly meta.function keyword.generator.asterisk -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: async function*(arg) {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.function -// ^^^^^ meta.group.braces.curly meta.function storage.type -// ^^^^^^^^ meta.group.braces.curly meta.function storage.type.function -// ^ meta.group.braces.curly meta.function keyword.generator.asterisk -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function variable.parameter.function -// ^ meta.group.braces.curly meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: async () => {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^^^^^^^ meta.group.braces.curly meta.function.arrow -// ^^^^^ meta.group.braces.curly meta.function.arrow storage.type -// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.group.braces.curly meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: async (arg) => {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^^^^^^^^^^ meta.group.braces.curly meta.function.arrow -// ^^^^^ meta.group.braces.curly meta.function.arrow storage.type -// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.arrow variable.parameter.function -// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.group.braces.curly meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: async arg => {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^^^^^^^^ meta.group.braces.curly meta.function.arrow -// ^^^^^ meta.group.braces.curly meta.function.arrow storage.type -// ^^^ meta.group.braces.curly meta.function.arrow variable.parameter.function -// ^^ meta.group.braces.curly meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: () => {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^ meta.group.braces.curly meta.function.arrow -// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.begin -// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.group.braces.curly meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: (arg) => {}, -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^^^^ meta.group.braces.curly meta.function.arrow -// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.begin -// ^^^ meta.group.braces.curly meta.function.arrow variable.parameter.function -// ^ meta.group.braces.curly meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.group.braces.curly meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.delimiter.comma - - [play]: arg => {} -//^ meta.group.braces.curly meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.curly meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.curly punctuation.separator.key-value -// ^^^^^^ meta.group.braces.curly meta.function.arrow -// ^^^ meta.group.braces.curly meta.function.arrow variable.parameter.function -// ^^ meta.group.braces.curly meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end - -} - -class Sound extends Model { -//^^^ meta.class storage.type.class -// ^^^^^ meta.class entity.name.class -// ^^^^^^ meta.class meta.flowtype.polymorph -// ^ meta.class meta.flowtype.polymorph punctuation.section.flowtype.begin -// ^ meta.class meta.flowtype.polymorph variable.other.flowtype -// ^ meta.class meta.flowtype.polymorph variable.other.flowtype -// ^ meta.class meta.flowtype.polymorph punctuation.section.flowtype.end -// ^^^^^^^^^^^^^^^^^^^^ meta.class meta.class.extends -// ^^^^^^^ meta.class meta.class.extends storage.type.extends -// ^^^^^ meta.class meta.class.extends variable.other.readwrite -// ^^^^^^ meta.class meta.class.extends meta.flowtype.polymorph -// ^ meta.class meta.class.extends meta.flowtype.polymorph punctuation.section.flowtype.begin -// ^ meta.class meta.class.extends meta.flowtype.polymorph variable.other.flowtype -// ^ meta.class meta.class.extends meta.flowtype.polymorph variable.other.flowtype -// ^ meta.class meta.class.extends meta.flowtype.polymorph punctuation.section.flowtype.end -// ^ meta.class meta.brace.curly.begin - get() {} -//^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - get(arg) {} -//^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - set() {} -//^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - set(arg) {} -//^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - *get() {} -//^ meta.class keyword.generator.asterisk -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - *get(arg) {} -//^ meta.class keyword.generator.asterisk -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - *set() {} -//^ meta.class keyword.generator.asterisk -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - *set(arg) {} -//^ meta.class keyword.generator.asterisk -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - async get() {} -//^^^^^ meta.class storage.type -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - async get(arg) {} -//^^^^^ meta.class storage.type -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - async set() {} -//^^^^^ meta.class storage.type -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - async set(arg) {} -//^^^^^ meta.class storage.type -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static get() {} -//^^^^^^ meta.class storage.modifier -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static get(arg) {} -//^^^^^^ meta.class storage.modifier -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static set() {} -//^^^^^^ meta.class storage.modifier -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static set(arg) {} -//^^^^^^ meta.class storage.modifier -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static *get() {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class keyword.generator.asterisk -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static *get(arg) {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class keyword.generator.asterisk -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static *set() {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class keyword.generator.asterisk -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static *set(arg) {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class keyword.generator.asterisk -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static async get() {} -//^^^^^^ meta.class storage.modifier -// ^^^^^ meta.class storage.type -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static async get(arg) {} -//^^^^^^ meta.class storage.modifier -// ^^^^^ meta.class storage.type -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static async set() {} -//^^^^^^ meta.class storage.modifier -// ^^^^^ meta.class storage.type -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static async set(arg) {} -//^^^^^^ meta.class storage.modifier -// ^^^^^ meta.class storage.type -// ^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static get get() {} -//^^^^^^ meta.class storage.modifier -// ^^^^ meta.class meta.class-accessor storage.type -// ^^^ meta.class meta.class-accessor string.unquoted entity.name.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin -// ^ meta.class meta.class-accessor punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static set set(arg) {} -//^^^^^^ meta.class storage.modifier -// ^^^^ meta.class meta.class-accessor storage.type -// ^^^ meta.class meta.class-accessor string.unquoted entity.name.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-accessor variable.parameter.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - play() {} -//^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - play(arg) {} -//^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - 'play'() {} -//^ meta.class meta.class-method string.quoted punctuation.definition.string.begin -// ^^^^ meta.class meta.class-method string.quoted entity.name.function -// ^ meta.class meta.class-method string.quoted punctuation.definition.string.end -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - 'play'(arg) {} -//^ meta.class meta.class-method string.quoted punctuation.definition.string.begin -// ^^^^ meta.class meta.class-method string.quoted entity.name.function -// ^ meta.class meta.class-method string.quoted punctuation.definition.string.end -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - *play() {} -//^ meta.class keyword.generator.asterisk -// ^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - *play(arg) {} -//^ meta.class keyword.generator.asterisk -// ^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - *'play'() {} -//^ meta.class keyword.generator.asterisk -// ^ meta.class meta.class-method string.quoted punctuation.definition.string.begin -// ^^^^ meta.class meta.class-method string.quoted entity.name.function -// ^ meta.class meta.class-method string.quoted punctuation.definition.string.end -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - *'play'(arg) {} -//^ meta.class keyword.generator.asterisk -// ^ meta.class meta.class-method string.quoted punctuation.definition.string.begin -// ^^^^ meta.class meta.class-method string.quoted entity.name.function -// ^ meta.class meta.class-method string.quoted punctuation.definition.string.end -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - async play() {} -//^^^^^ meta.class storage.type -// ^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - async play(arg) {} -//^^^^^ meta.class storage.type -// ^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - get play() {} -//^^^^ meta.class meta.class-accessor storage.type -// ^^^^ meta.class meta.class-accessor string.unquoted entity.name.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin -// ^ meta.class meta.class-accessor punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - set play(arg) {} -//^^^^ meta.class meta.class-accessor storage.type -// ^^^^ meta.class meta.class-accessor string.unquoted entity.name.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-accessor variable.parameter.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static play() {} -//^^^^^^ meta.class storage.modifier -// ^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static play(arg) {} -//^^^^^^ meta.class storage.modifier -// ^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static *play() {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class keyword.generator.asterisk -// ^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static *play(arg) {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class keyword.generator.asterisk -// ^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static async play() {} -//^^^^^^ meta.class storage.modifier -// ^^^^^ meta.class storage.type -// ^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static async play(arg) {} -//^^^^^^ meta.class storage.modifier -// ^^^^^ meta.class storage.type -// ^^^^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static get play() {} -//^^^^^^ meta.class storage.modifier -// ^^^^ meta.class meta.class-accessor storage.type -// ^^^^ meta.class meta.class-accessor string.unquoted entity.name.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin -// ^ meta.class meta.class-accessor punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static set play(arg) {} -//^^^^^^ meta.class storage.modifier -// ^^^^ meta.class meta.class-accessor storage.type -// ^^^^ meta.class meta.class-accessor string.unquoted entity.name.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-accessor variable.parameter.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - 0() {} -//^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - 0(arg) {} -//^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - *0() {} -//^ meta.class keyword.generator.asterisk -// ^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - *0(arg) {} -//^ meta.class keyword.generator.asterisk -// ^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - async 0() {} -//^^^^^ meta.class storage.type -// ^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - async 0(arg) {} -//^^^^^ meta.class storage.type -// ^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - get 0() {} -//^^^^ meta.class meta.class-accessor storage.type -// ^ meta.class meta.class-accessor string.unquoted entity.name.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin -// ^ meta.class meta.class-accessor punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - set 0(arg) {} -//^^^^ meta.class meta.class-accessor storage.type -// ^ meta.class meta.class-accessor string.unquoted entity.name.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-accessor variable.parameter.function -// ^ meta.class meta.class-accessor punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static 0() {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static 0(arg) {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static *0() {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class keyword.generator.asterisk -// ^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static *0(arg) {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class keyword.generator.asterisk -// ^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static async 0() {} -//^^^^^^ meta.class storage.modifier -// ^^^^^ meta.class storage.type -// ^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static async 0(arg) {} -//^^^^^^ meta.class storage.modifier -// ^^^^^ meta.class storage.type -// ^ meta.class meta.class-method string.unquoted entity.name.function -// ^ meta.class meta.class-method punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method variable.parameter.function -// ^ meta.class meta.class-method punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - [play]() {} -//^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - [play](arg) {} -//^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method.computed variable.parameter.function -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - *[play]() {} -//^ meta.class keyword.generator.asterisk -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - *[play](arg) {} -//^ meta.class keyword.generator.asterisk -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method.computed variable.parameter.function -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - async [play]() {} -//^^^^^ meta.class storage.type -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - async [play](arg) {} -//^^^^^ meta.class storage.type -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method.computed variable.parameter.function -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - get [play]() {} -//^^^ meta.class storage.type -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - set [play](arg) {} -//^^^ meta.class storage.type -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method.computed variable.parameter.function -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static [play]() {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static [play](arg) {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method.computed variable.parameter.function -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static *[play]() {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class keyword.generator.asterisk -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static *[play](arg) {} -//^^^^^^ meta.class storage.modifier -// ^ meta.class keyword.generator.asterisk -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method.computed variable.parameter.function -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static async [play]() {} -//^^^^^^ meta.class storage.modifier -// ^^^^^ meta.class storage.type -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static async [play](arg) {} -//^^^^^^ meta.class storage.modifier -// ^^^^^ meta.class storage.type -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method.computed variable.parameter.function -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static get [play]() {} -//^^^^^^ meta.class storage.modifier -// ^^^ meta.class storage.type -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end - static set [play](arg) {} -//^^^^^^ meta.class storage.modifier -// ^^^ meta.class storage.type -// ^ meta.class meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.class meta.group.braces.square variable.other.readwrite -// ^ meta.class meta.group.braces.square meta.brace.square.end -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.begin -// ^^^ meta.class meta.class-method.computed variable.parameter.function -// ^ meta.class meta.class-method.computed punctuation.definition.parameters.end -// ^ meta.class meta.group.braces.curly meta.brace.curly.begin -// ^ meta.class meta.group.braces.curly meta.brace.curly.end -} -//<- meta.class meta.brace.curly.end - - -Sound -//^^^ variable.other.readwrite -Sound() -//^^^ meta.function-call.without-arguments variable.function -// ^^ meta.function-call.without-arguments meta.group.braces.round.function.arguments -Sound = {} -//^^^ variable.other.readwrite -//<- source.js -// ^ keyword.operator.assignment -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play -//^^^ meta.property.class variable.other.class -// ^ meta.property.class keyword.operator.accessor -// ^^^^ meta.property.class variable.other.property.static -Sound[play] -//^^^ variable.other.object variable.other.object -// ^ meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.square meta.brace.square.end -Sound.play() -//^^^ meta.function-call.static.without-arguments variable.other.class -// ^ meta.function-call.static.without-arguments keyword.operator.accessor -// ^^^^ meta.function-call.static.without-arguments variable.function -// ^^ meta.function-call.static.without-arguments meta.group.braces.round.function.arguments -Sound[play]() -//^^^ variable.other.object variable.other.object -// ^ meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.round meta.brace.round.begin -// ^ meta.group.braces.round meta.brace.round.end -Sound.play = {} -//^^^ meta.property.class variable.other.class -//<- source.js -// ^ meta.property.class keyword.operator.accessor -// ^^^^ meta.property.class variable.other.property.static -// ^ keyword.operator.assignment -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound[play] = {} -//^^^ variable.other.object variable.other.object -//<- source.js -// ^ meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.square meta.brace.square.end -// ^ keyword.operator.assignment -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype -//^^^ meta.prototype.access entity.name.class -// ^ meta.prototype.access keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.access variable.language.prototype -Sound.prototype() -//^^^ meta.prototype.access entity.name.class -// ^ meta.prototype.access keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.access variable.language.prototype -// ^ meta.group.braces.round meta.brace.round.begin -// ^ meta.group.braces.round meta.brace.round.end -Sound.prototype = {} -//^^^^^^^^^^^^^^^^ meta.prototype.declaration -//^^^ meta.prototype.declaration entity.name.class -// ^ meta.prototype.declaration keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.declaration variable.language.prototype -// ^ meta.prototype.declaration keyword.operator.assignment -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play -//^^^ meta.prototype.access entity.name.class -// ^ meta.prototype.access keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.access variable.language.prototype -// ^ keyword.operator.accessor -// ^^^^ meta.property.object variable.other.property -Sound.prototype.play() -//^^^ meta.prototype.access entity.name.class -// ^ meta.prototype.access keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.access variable.language.prototype -// ^ keyword.operator.accessor -// ^^^^ meta.function-call.method.without-arguments variable.function -// ^^ meta.function-call.method.without-arguments meta.group.braces.round.function.arguments -Sound.prototype[play]() -//^^^ meta.prototype.access entity.name.class -// ^ meta.prototype.access keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.access variable.language.prototype -// ^ meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.round meta.brace.round.begin -// ^ meta.group.braces.round meta.brace.round.end -Sound.prototype.play = -//^^^ meta.prototype.access entity.name.class -//<- source.js -// ^ meta.prototype.access keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.access variable.language.prototype -// ^ keyword.operator.accessor -// ^^^^ meta.property.object variable.other.property -// ^ keyword.operator.assignment -Sound.prototype[play] = -//^^^ meta.prototype.access entity.name.class -//<- source.js -// ^ meta.prototype.access keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.access variable.language.prototype -// ^ meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.square meta.brace.square.end -// ^ keyword.operator.assignment -Sound.play.repeat -//^^^ meta.property.class variable.other.class -// ^ meta.property.class keyword.operator.accessor -// ^^^^ meta.property.class variable.other.property.static -// ^ keyword.operator.accessor -// ^^^^^^ meta.property.object variable.other.property -Sound[play].repeat -//^^^ variable.other.object variable.other.object -// ^ meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.square meta.brace.square.end -// ^ keyword.operator.accessor -// ^^^^^^ meta.property.object variable.other.property -Sound.play.repeat() -//^^^ meta.property.class variable.other.class -// ^ meta.property.class keyword.operator.accessor -// ^^^^ meta.property.class variable.other.property.static -// ^ keyword.operator.accessor -// ^^^^^^ meta.function-call.method.without-arguments variable.function -// ^^ meta.function-call.method.without-arguments meta.group.braces.round.function.arguments -Sound[play].repeat() -//^^^ variable.other.object variable.other.object -// ^ meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.square meta.brace.square.end -// ^ keyword.operator.accessor -// ^^^^^^ meta.function-call.method.without-arguments variable.function -// ^^ meta.function-call.method.without-arguments meta.group.braces.round.function.arguments -Sound.play.repeat = {} -//^^^ meta.property.class variable.other.class -//<- source.js -// ^ meta.property.class keyword.operator.accessor -// ^^^^ meta.property.class variable.other.property.static -// ^ keyword.operator.accessor -// ^^^^^^ meta.property.object variable.other.property -// ^ keyword.operator.assignment -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound[play].repeat = {} -//^^^ variable.other.object variable.other.object -//<- source.js -// ^ meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.square meta.brace.square.end -// ^ keyword.operator.accessor -// ^^^^^^ meta.property.object variable.other.property -// ^ keyword.operator.assignment -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - - -Sound.prototype.play = function() {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype -//^^^ meta.function.prototype entity.name.class -//<- source.js -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^^^^^^ meta.function.prototype variable.language.prototype -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype keyword.operator.assignment -// ^^^^^^^^ meta.function.prototype storage.type.function -// ^ meta.function.prototype punctuation.definition.parameters.begin -// ^ meta.function.prototype punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play = function(arg) {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype -//^^^ meta.function.prototype entity.name.class -//<- source.js -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^^^^^^ meta.function.prototype variable.language.prototype -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype keyword.operator.assignment -// ^^^^^^^^ meta.function.prototype storage.type.function -// ^ meta.function.prototype punctuation.definition.parameters.begin -// ^^^ meta.function.prototype variable.parameter.function -// ^ meta.function.prototype punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play = function*() {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype -//^^^ meta.function.prototype entity.name.class -//<- source.js -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^^^^^^ meta.function.prototype variable.language.prototype -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype keyword.operator.assignment -// ^^^^^^^^ meta.function.prototype storage.type.function -// ^ meta.function.prototype keyword.generator.asterisk -// ^ meta.function.prototype punctuation.definition.parameters.begin -// ^ meta.function.prototype punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play = function*(arg) {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype -//^^^ meta.function.prototype entity.name.class -//<- source.js -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^^^^^^ meta.function.prototype variable.language.prototype -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype keyword.operator.assignment -// ^^^^^^^^ meta.function.prototype storage.type.function -// ^ meta.function.prototype keyword.generator.asterisk -// ^ meta.function.prototype punctuation.definition.parameters.begin -// ^^^ meta.function.prototype variable.parameter.function -// ^ meta.function.prototype punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play = async function() {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype -//^^^ meta.function.prototype entity.name.class -//<- source.js -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^^^^^^ meta.function.prototype variable.language.prototype -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype keyword.operator.assignment -// ^^^^^ meta.function.prototype storage.type -// ^^^^^^^^ meta.function.prototype storage.type.function -// ^ meta.function.prototype punctuation.definition.parameters.begin -// ^ meta.function.prototype punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play = async function(arg) {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype -//^^^ meta.function.prototype entity.name.class -//<- source.js -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^^^^^^ meta.function.prototype variable.language.prototype -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype keyword.operator.assignment -// ^^^^^ meta.function.prototype storage.type -// ^^^^^^^^ meta.function.prototype storage.type.function -// ^ meta.function.prototype punctuation.definition.parameters.begin -// ^^^ meta.function.prototype variable.parameter.function -// ^ meta.function.prototype punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play = async function*() {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype -//^^^ meta.function.prototype entity.name.class -//<- source.js -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^^^^^^ meta.function.prototype variable.language.prototype -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype keyword.operator.assignment -// ^^^^^ meta.function.prototype storage.type -// ^^^^^^^^ meta.function.prototype storage.type.function -// ^ meta.function.prototype keyword.generator.asterisk -// ^ meta.function.prototype punctuation.definition.parameters.begin -// ^ meta.function.prototype punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play = async function*(arg) {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype -//^^^ meta.function.prototype entity.name.class -//<- source.js -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^^^^^^ meta.function.prototype variable.language.prototype -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype keyword.operator.assignment -// ^^^^^ meta.function.prototype storage.type -// ^^^^^^^^ meta.function.prototype storage.type.function -// ^ meta.function.prototype keyword.generator.asterisk -// ^ meta.function.prototype punctuation.definition.parameters.begin -// ^^^ meta.function.prototype variable.parameter.function -// ^ meta.function.prototype punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play = async () => {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow -//^^^ meta.prototype.function.arrow entity.name.class -//<- source.js -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^ meta.prototype.function.arrow entity.name.function -// ^ meta.prototype.function.arrow keyword.operator.assignment -// ^^^^^ meta.prototype.function.arrow storage.type -// ^ meta.prototype.function.arrow punctuation.definition.parameters.begin -// ^ meta.prototype.function.arrow punctuation.definition.parameters.end -// ^^ meta.prototype.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play = async (arg) => {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow -//^^^ meta.prototype.function.arrow entity.name.class -//<- source.js -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^ meta.prototype.function.arrow entity.name.function -// ^ meta.prototype.function.arrow keyword.operator.assignment -// ^^^^^ meta.prototype.function.arrow storage.type -// ^ meta.prototype.function.arrow punctuation.definition.parameters.begin -// ^^^ meta.prototype.function.arrow variable.parameter.function -// ^ meta.prototype.function.arrow punctuation.definition.parameters.end -// ^^ meta.prototype.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play = async arg => {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow -//^^^ meta.prototype.function.arrow entity.name.class -//<- source.js -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^ meta.prototype.function.arrow entity.name.function -// ^ meta.prototype.function.arrow keyword.operator.assignment -// ^^^^^ meta.prototype.function.arrow storage.type -// ^^^ meta.prototype.function.arrow variable.parameter.function -// ^^ meta.prototype.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play = () => {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow -//^^^ meta.prototype.function.arrow entity.name.class -//<- source.js -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^ meta.prototype.function.arrow entity.name.function -// ^ meta.prototype.function.arrow keyword.operator.assignment -// ^ meta.prototype.function.arrow punctuation.definition.parameters.begin -// ^ meta.prototype.function.arrow punctuation.definition.parameters.end -// ^^ meta.prototype.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play = (arg) => {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow -//^^^ meta.prototype.function.arrow entity.name.class -//<- source.js -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^ meta.prototype.function.arrow entity.name.function -// ^ meta.prototype.function.arrow keyword.operator.assignment -// ^ meta.prototype.function.arrow punctuation.definition.parameters.begin -// ^^^ meta.prototype.function.arrow variable.parameter.function -// ^ meta.prototype.function.arrow punctuation.definition.parameters.end -// ^^ meta.prototype.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.play = arg => {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow -//^^^ meta.prototype.function.arrow entity.name.class -//<- source.js -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^ meta.prototype.function.arrow entity.name.function -// ^ meta.prototype.function.arrow keyword.operator.assignment -// ^^^ meta.prototype.function.arrow variable.parameter.function -// ^^ meta.prototype.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - - -Sound.play = function() {} -//^^^^^^^^^^^^^^^^^^^^^ meta.function.static -//^^^ meta.function.static entity.name.class -//<- source.js -// ^ meta.function.static keyword.operator.accessor -// ^^^^ meta.function.static entity.name.function -// ^ meta.function.static keyword.operator.assignment -// ^^^^^^^^ meta.function.static storage.type.function -// ^ meta.function.static punctuation.definition.parameters.begin -// ^ meta.function.static punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play = function(arg) {} -//^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static -//^^^ meta.function.static entity.name.class -//<- source.js -// ^ meta.function.static keyword.operator.accessor -// ^^^^ meta.function.static entity.name.function -// ^ meta.function.static keyword.operator.assignment -// ^^^^^^^^ meta.function.static storage.type.function -// ^ meta.function.static punctuation.definition.parameters.begin -// ^^^ meta.function.static variable.parameter.function -// ^ meta.function.static punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play = function*() {} -//^^^^^^^^^^^^^^^^^^^^^^ meta.function.static -//^^^ meta.function.static entity.name.class -//<- source.js -// ^ meta.function.static keyword.operator.accessor -// ^^^^ meta.function.static entity.name.function -// ^ meta.function.static keyword.operator.assignment -// ^^^^^^^^ meta.function.static storage.type.function -// ^ meta.function.static keyword.generator.asterisk -// ^ meta.function.static punctuation.definition.parameters.begin -// ^ meta.function.static punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play = function*(arg) {} -//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static -//^^^ meta.function.static entity.name.class -//<- source.js -// ^ meta.function.static keyword.operator.accessor -// ^^^^ meta.function.static entity.name.function -// ^ meta.function.static keyword.operator.assignment -// ^^^^^^^^ meta.function.static storage.type.function -// ^ meta.function.static keyword.generator.asterisk -// ^ meta.function.static punctuation.definition.parameters.begin -// ^^^ meta.function.static variable.parameter.function -// ^ meta.function.static punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play = async function() {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static -//^^^ meta.function.static entity.name.class -//<- source.js -// ^ meta.function.static keyword.operator.accessor -// ^^^^ meta.function.static entity.name.function -// ^ meta.function.static keyword.operator.assignment -// ^^^^^ meta.function.static storage.type -// ^^^^^^^^ meta.function.static storage.type.function -// ^ meta.function.static punctuation.definition.parameters.begin -// ^ meta.function.static punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play = async function(arg) {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static -//^^^ meta.function.static entity.name.class -//<- source.js -// ^ meta.function.static keyword.operator.accessor -// ^^^^ meta.function.static entity.name.function -// ^ meta.function.static keyword.operator.assignment -// ^^^^^ meta.function.static storage.type -// ^^^^^^^^ meta.function.static storage.type.function -// ^ meta.function.static punctuation.definition.parameters.begin -// ^^^ meta.function.static variable.parameter.function -// ^ meta.function.static punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play = async function*() {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static -//^^^ meta.function.static entity.name.class -//<- source.js -// ^ meta.function.static keyword.operator.accessor -// ^^^^ meta.function.static entity.name.function -// ^ meta.function.static keyword.operator.assignment -// ^^^^^ meta.function.static storage.type -// ^^^^^^^^ meta.function.static storage.type.function -// ^ meta.function.static keyword.generator.asterisk -// ^ meta.function.static punctuation.definition.parameters.begin -// ^ meta.function.static punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play = async function*(arg) {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static -//^^^ meta.function.static entity.name.class -//<- source.js -// ^ meta.function.static keyword.operator.accessor -// ^^^^ meta.function.static entity.name.function -// ^ meta.function.static keyword.operator.assignment -// ^^^^^ meta.function.static storage.type -// ^^^^^^^^ meta.function.static storage.type.function -// ^ meta.function.static keyword.generator.asterisk -// ^ meta.function.static punctuation.definition.parameters.begin -// ^^^ meta.function.static variable.parameter.function -// ^ meta.function.static punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play = async () => {} -//^^^^^^^^^^^^^^^^^^^^^^ meta.function.static.arrow -//^^^ meta.function.static.arrow entity.name.class -//<- source.js -// ^ meta.function.static.arrow keyword.operator.accessor -// ^^^^ meta.function.static.arrow entity.name.function -// ^ meta.function.static.arrow keyword.operator.assignment -// ^^^^^ meta.function.static.arrow storage.type -// ^ meta.function.static.arrow punctuation.definition.parameters.begin -// ^ meta.function.static.arrow punctuation.definition.parameters.end -// ^^ meta.function.static.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play = async (arg) => {} -//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static.arrow -//^^^ meta.function.static.arrow entity.name.class -//<- source.js -// ^ meta.function.static.arrow keyword.operator.accessor -// ^^^^ meta.function.static.arrow entity.name.function -// ^ meta.function.static.arrow keyword.operator.assignment -// ^^^^^ meta.function.static.arrow storage.type -// ^ meta.function.static.arrow punctuation.definition.parameters.begin -// ^^^ meta.function.static.arrow variable.parameter.function -// ^ meta.function.static.arrow punctuation.definition.parameters.end -// ^^ meta.function.static.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play = async arg => {} -//^^^^^^^^^^^^^^^^^^^^^^^ meta.function.static.arrow -//^^^ meta.function.static.arrow entity.name.class -//<- source.js -// ^ meta.function.static.arrow keyword.operator.accessor -// ^^^^ meta.function.static.arrow entity.name.function -// ^ meta.function.static.arrow keyword.operator.assignment -// ^^^^^ meta.function.static.arrow storage.type -// ^^^ meta.function.static.arrow variable.parameter.function -// ^^ meta.function.static.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play = () => {} -//^^^^^^^^^^^^^^^^ meta.function.static.arrow -//^^^ meta.function.static.arrow entity.name.class -//<- source.js -// ^ meta.function.static.arrow keyword.operator.accessor -// ^^^^ meta.function.static.arrow entity.name.function -// ^ meta.function.static.arrow keyword.operator.assignment -// ^ meta.function.static.arrow punctuation.definition.parameters.begin -// ^ meta.function.static.arrow punctuation.definition.parameters.end -// ^^ meta.function.static.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play = (arg) => {} -//^^^^^^^^^^^^^^^^^^^ meta.function.static.arrow -//^^^ meta.function.static.arrow entity.name.class -//<- source.js -// ^ meta.function.static.arrow keyword.operator.accessor -// ^^^^ meta.function.static.arrow entity.name.function -// ^ meta.function.static.arrow keyword.operator.assignment -// ^ meta.function.static.arrow punctuation.definition.parameters.begin -// ^^^ meta.function.static.arrow variable.parameter.function -// ^ meta.function.static.arrow punctuation.definition.parameters.end -// ^^ meta.function.static.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.play = arg => {} -//^^^^^^^^^^^^^^^^^ meta.function.static.arrow -//^^^ meta.function.static.arrow entity.name.class -//<- source.js -// ^ meta.function.static.arrow keyword.operator.accessor -// ^^^^ meta.function.static.arrow entity.name.function -// ^ meta.function.static.arrow keyword.operator.assignment -// ^^^ meta.function.static.arrow variable.parameter.function -// ^^ meta.function.static.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -play = function() {} -//^^^^^^^^^^^^^^^ meta.function -//^^ meta.function entity.name.function -//<- source.js -// ^ meta.function keyword.operator.assignment -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -play = function(arg) {} -//^^^^^^^^^^^^^^^^^^ meta.function -//^^ meta.function entity.name.function -//<- source.js -// ^ meta.function keyword.operator.assignment -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function punctuation.definition.parameters.begin -// ^^^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -play = function*() {} -//^^^^^^^^^^^^^^^^ meta.function -//^^ meta.function entity.name.function -//<- source.js -// ^ meta.function keyword.operator.assignment -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function keyword.generator.asterisk -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -play = function*(arg) {} -//^^^^^^^^^^^^^^^^^^^ meta.function -//^^ meta.function entity.name.function -//<- source.js -// ^ meta.function keyword.operator.assignment -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function keyword.generator.asterisk -// ^ meta.function punctuation.definition.parameters.begin -// ^^^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -play = async function() {} -//^^^^^^^^^^^^^^^^^^^^^ meta.function -//^^ meta.function entity.name.function -//<- source.js -// ^ meta.function keyword.operator.assignment -// ^^^^^ meta.function storage.type -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -play = async function(arg) {} -//^^^^^^^^^^^^^^^^^^^^^^^^ meta.function -//^^ meta.function entity.name.function -//<- source.js -// ^ meta.function keyword.operator.assignment -// ^^^^^ meta.function storage.type -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function punctuation.definition.parameters.begin -// ^^^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -play = async function*() {} -//^^^^^^^^^^^^^^^^^^^^^^ meta.function -//^^ meta.function entity.name.function -//<- source.js -// ^ meta.function keyword.operator.assignment -// ^^^^^ meta.function storage.type -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function keyword.generator.asterisk -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -play = async function*(arg) {} -//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function -//^^ meta.function entity.name.function -//<- source.js -// ^ meta.function keyword.operator.assignment -// ^^^^^ meta.function storage.type -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function keyword.generator.asterisk -// ^ meta.function punctuation.definition.parameters.begin -// ^^^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -play = async () => {} -//^^^^^^^^^^^^^^^^ meta.function.arrow -//^^ meta.function.arrow entity.name.function -//<- source.js -// ^ meta.function.arrow keyword.operator.assignment -// ^^^^^ meta.function.arrow storage.type -// ^ meta.function.arrow punctuation.definition.parameters.begin -// ^ meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -play = async (arg) => {} -//^^^^^^^^^^^^^^^^^^^ meta.function.arrow -//^^ meta.function.arrow entity.name.function -//<- source.js -// ^ meta.function.arrow keyword.operator.assignment -// ^^^^^ meta.function.arrow storage.type -// ^ meta.function.arrow punctuation.definition.parameters.begin -// ^^^ meta.function.arrow variable.parameter.function -// ^ meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -play = async arg => {} -//^^^^^^^^^^^^^^^^^ meta.function.arrow -//^^ meta.function.arrow entity.name.function -//<- source.js -// ^ meta.function.arrow keyword.operator.assignment -// ^^^^^ meta.function.arrow storage.type -// ^^^ meta.function.arrow variable.parameter.function -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -play = () => {} -//^^^^^^^^^^ meta.function.arrow -//^^ meta.function.arrow entity.name.function -//<- source.js -// ^ meta.function.arrow keyword.operator.assignment -// ^ meta.function.arrow punctuation.definition.parameters.begin -// ^ meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -play = (arg) => {} -//^^^^^^^^^^^^^ meta.function.arrow -//^^ meta.function.arrow entity.name.function -//<- source.js -// ^ meta.function.arrow keyword.operator.assignment -// ^ meta.function.arrow punctuation.definition.parameters.begin -// ^^^ meta.function.arrow variable.parameter.function -// ^ meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -play = arg => {} -//^^^^^^^^^^^ meta.function.arrow -//^^ meta.function.arrow entity.name.function -//<- source.js -// ^ meta.function.arrow keyword.operator.assignment -// ^^^ meta.function.arrow variable.parameter.function -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - - -return function() {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return function(arg) {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function punctuation.definition.parameters.begin -// ^^^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return function*() {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function keyword.generator.asterisk -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return function*(arg) {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function keyword.generator.asterisk -// ^ meta.function punctuation.definition.parameters.begin -// ^^^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return async function() {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^^^^^ meta.function -// ^^^^^ meta.function storage.type -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return async function(arg) {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^^^^^^^^ meta.function -// ^^^^^ meta.function storage.type -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function punctuation.definition.parameters.begin -// ^^^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return async function*() {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^^^^^^ meta.function -// ^^^^^ meta.function storage.type -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function keyword.generator.asterisk -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return async function*(arg) {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^^^^^^^^^ meta.function -// ^^^^^ meta.function storage.type -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function keyword.generator.asterisk -// ^ meta.function punctuation.definition.parameters.begin -// ^^^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return async () => {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^ meta.function.arrow -// ^^^^^ meta.function.arrow storage.type -// ^ meta.function.arrow punctuation.definition.parameters.begin -// ^ meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return async (arg) => {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^^^ meta.function.arrow -// ^^^^^ meta.function.arrow storage.type -// ^ meta.function.arrow punctuation.definition.parameters.begin -// ^^^ meta.function.arrow variable.parameter.function -// ^ meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return async arg => {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^ meta.function.arrow -// ^^^^^ meta.function.arrow storage.type -// ^^^ meta.function.arrow variable.parameter.function -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return () => {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^ meta.function.arrow -// ^ meta.function.arrow punctuation.definition.parameters.begin -// ^ meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return (arg) => {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^ meta.function.arrow -// ^ meta.function.arrow punctuation.definition.parameters.begin -// ^^^ meta.function.arrow variable.parameter.function -// ^ meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return arg => {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^ meta.function.arrow -// ^^^ meta.function.arrow variable.parameter.function -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -return function play() {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^^^^ meta.function -// ^^^^^^^^ meta.function storage.type.function -// ^^^^ meta.function entity.name.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return function play(arg) {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^^^^^^^ meta.function -// ^^^^^^^^ meta.function storage.type.function -// ^^^^ meta.function entity.name.function -// ^ meta.function punctuation.definition.parameters.begin -// ^^^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return function* play() {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^^^^^ meta.function -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function keyword.generator.asterisk -// ^^^^ meta.function entity.name.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return function* play(arg) {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^^^^^^^^ meta.function -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function keyword.generator.asterisk -// ^^^^ meta.function entity.name.function -// ^ meta.function punctuation.definition.parameters.begin -// ^^^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return async function play() {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^^^^^^^^^^ meta.function -// ^^^^^ meta.function storage.type -// ^^^^^^^^ meta.function storage.type.function -// ^^^^ meta.function entity.name.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return async function play(arg) {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.function -// ^^^^^ meta.function storage.type -// ^^^^^^^^ meta.function storage.type.function -// ^^^^ meta.function entity.name.function -// ^ meta.function punctuation.definition.parameters.begin -// ^^^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return async function* play() {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^^^^^^^^^^^ meta.function -// ^^^^^ meta.function storage.type -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function keyword.generator.asterisk -// ^^^^ meta.function entity.name.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -return async function* play(arg) {} -//^^^^ keyword.control.flow -//<- source.js -// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function -// ^^^^^ meta.function storage.type -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function keyword.generator.asterisk -// ^^^^ meta.function entity.name.function -// ^ meta.function punctuation.definition.parameters.begin -// ^^^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -yield genfunc; -//^^^ keyword.control.flow -//<- source.js -// ^^^^^^^ variable.other.readwrite -// ^ punctuation.terminator.statement -yield* genfunc; -//^^^ keyword.control.flow -//<- source.js -// ^ keyword.generator.asterisk -// ^^^^^^^ variable.other.readwrite -// ^ punctuation.terminator.statement - - -/** - * Not matched as function definitions - */ - -Sound[play] = function(){} -//^^^ variable.other.object variable.other.object -//<- source.js -// ^ meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.square meta.brace.square.end -// ^ keyword.operator.assignment -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -Sound.prototype.[play] = function(){} -//^^^ meta.prototype.access entity.name.class -//<- source.js -// ^ meta.prototype.access keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.access variable.language.prototype -// ^ keyword.operator.accessor -// ^ meta.group.braces.square meta.brace.square.begin -// ^^^^ meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.square meta.brace.square.end -// ^ keyword.operator.assignment -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - - -A = function() {} -//^^^^^^^^^^^^ meta.function -//^ meta.function keyword.operator.assignment -//<- source.js -//<- meta.function entity.name.function -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -B = function(z) {} -//^^^^^^^^^^^^^ meta.function -//^ meta.function keyword.operator.assignment -//<- source.js -//<- meta.function entity.name.function -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -C = function c() {} -//^^^^^^^^^^^^^^ meta.function -//^ meta.function keyword.operator.assignment -//<- source.js -//<- meta.function entity.name.function -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function entity.name.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -D = function d(z) {} -//^^^^^^^^^^^^^^^ meta.function -//^ meta.function keyword.operator.assignment -//<- source.js -//<- meta.function entity.name.function -// ^^^^^^^^ meta.function storage.type.function -// ^ meta.function entity.name.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -E = () => {} -//^^^^^^^ meta.function.arrow -//^ meta.function.arrow keyword.operator.assignment -//<- source.js -//<- meta.function.arrow entity.name.function -// ^ meta.function.arrow punctuation.definition.parameters.begin -// ^ meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -F = (z) => {} -//^^^^^^^^ meta.function.arrow -//^ meta.function.arrow keyword.operator.assignment -//<- source.js -//<- meta.function.arrow entity.name.function -// ^ meta.function.arrow punctuation.definition.parameters.begin -// ^ meta.function.arrow variable.parameter.function -// ^ meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -G = z => {} -//^^^^^^ meta.function.arrow -//^ meta.function.arrow keyword.operator.assignment -//<- source.js -//<- meta.function.arrow entity.name.function -// ^ meta.function.arrow variable.parameter.function -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -function() {} -//^^^^^^ meta.function storage.type.function -//<- source.js -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -function(z) {} -//^^^^^^ meta.function storage.type.function -//<- source.js -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -function H() {} -//^^^^^^^^^^ meta.function -//^^^^^^ meta.function storage.type.function -//<- source.js -// ^ meta.function entity.name.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -function I(z) {} -//^^^^^^^^^^^ meta.function -//^^^^^^ meta.function storage.type.function -//<- source.js -// ^ meta.function entity.name.function -// ^ meta.function punctuation.definition.parameters.begin -// ^ meta.function variable.parameter.function -// ^ meta.function punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -() => {} -//^^^ meta.function.arrow -//<- source.js -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -(zzz) => {} -//^^^^^^ meta.function.arrow -//^ meta.function.arrow variable.parameter.function -//<- source.js -//<- meta.function.arrow punctuation.definition.parameters.begin -// ^ meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -JJJ.prototype.jjj = () => {} -//^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow -//^ meta.prototype.function.arrow entity.name.class -//<- source.js -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^ meta.prototype.function.arrow entity.name.function -// ^ meta.prototype.function.arrow keyword.operator.assignment -// ^ meta.prototype.function.arrow punctuation.definition.parameters.begin -// ^ meta.prototype.function.arrow punctuation.definition.parameters.end -// ^^ meta.prototype.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -KKK.prototype.kkk = (z) => {} -//^^^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow -//^ meta.prototype.function.arrow entity.name.class -//<- source.js -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^ meta.prototype.function.arrow entity.name.function -// ^ meta.prototype.function.arrow keyword.operator.assignment -// ^ meta.prototype.function.arrow punctuation.definition.parameters.begin -// ^ meta.prototype.function.arrow variable.parameter.function -// ^ meta.prototype.function.arrow punctuation.definition.parameters.end -// ^^ meta.prototype.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -LLL.prototype.lll = z => {} -//^^^^^^^^^^^^^^^^^^^^^^ meta.prototype.function.arrow -//^ meta.prototype.function.arrow entity.name.class -//<- source.js -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^^^^^^^ meta.prototype.function.arrow variable.language.prototype -// ^ meta.prototype.function.arrow keyword.operator.accessor -// ^^^ meta.prototype.function.arrow entity.name.function -// ^ meta.prototype.function.arrow keyword.operator.assignment -// ^ meta.prototype.function.arrow variable.parameter.function -// ^^ meta.prototype.function.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -MMM.prototype.mmm = function() {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype -//^ meta.function.prototype entity.name.class -//<- source.js -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^^^^^^ meta.function.prototype variable.language.prototype -// ^ meta.function.prototype keyword.operator.accessor -// ^^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype keyword.operator.assignment -// ^^^^^^^^ meta.function.prototype storage.type.function -// ^ meta.function.prototype punctuation.definition.parameters.begin -// ^ meta.function.prototype punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -NNN.prototype.nnn = function(z) {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype -//^ meta.function.prototype entity.name.class -//<- source.js -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^^^^^^ meta.function.prototype variable.language.prototype -// ^ meta.function.prototype keyword.operator.accessor -// ^^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype keyword.operator.assignment -// ^^^^^^^^ meta.function.prototype storage.type.function -// ^ meta.function.prototype punctuation.definition.parameters.begin -// ^ meta.function.prototype variable.parameter.function -// ^ meta.function.prototype punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -OOO.prototype.ooo = function oo() {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype -//^ meta.function.prototype entity.name.class -//<- source.js -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^^^^^^ meta.function.prototype variable.language.prototype -// ^ meta.function.prototype keyword.operator.accessor -// ^^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype keyword.operator.assignment -// ^^^^^^^^ meta.function.prototype storage.type.function -// ^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype punctuation.definition.parameters.begin -// ^ meta.function.prototype punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -PPP.prototype.ppp = function pp(z) {} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.prototype -//^ meta.function.prototype entity.name.class -//<- source.js -// ^ meta.function.prototype keyword.operator.accessor -// ^^^^^^^^^ meta.function.prototype variable.language.prototype -// ^ meta.function.prototype keyword.operator.accessor -// ^^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype keyword.operator.assignment -// ^^^^^^^^ meta.function.prototype storage.type.function -// ^^ meta.function.prototype entity.name.function -// ^ meta.function.prototype punctuation.definition.parameters.begin -// ^ meta.function.prototype variable.parameter.function -// ^ meta.function.prototype punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -QQQ.qqq = () => {} -//^^^^^^^^^^^^^ meta.function.static.arrow -//^ meta.function.static.arrow entity.name.class -//<- source.js -// ^ meta.function.static.arrow keyword.operator.accessor -// ^^^ meta.function.static.arrow entity.name.function -// ^ meta.function.static.arrow keyword.operator.assignment -// ^ meta.function.static.arrow punctuation.definition.parameters.begin -// ^ meta.function.static.arrow punctuation.definition.parameters.end -// ^^ meta.function.static.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -RRR.rrr = (z) => {} -//^^^^^^^^^^^^^^ meta.function.static.arrow -//^ meta.function.static.arrow entity.name.class -//<- source.js -// ^ meta.function.static.arrow keyword.operator.accessor -// ^^^ meta.function.static.arrow entity.name.function -// ^ meta.function.static.arrow keyword.operator.assignment -// ^ meta.function.static.arrow punctuation.definition.parameters.begin -// ^ meta.function.static.arrow variable.parameter.function -// ^ meta.function.static.arrow punctuation.definition.parameters.end -// ^^ meta.function.static.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -SSS.sss = z => {} -//^^^^^^^^^^^^ meta.function.static.arrow -//^ meta.function.static.arrow entity.name.class -//<- source.js -// ^ meta.function.static.arrow keyword.operator.accessor -// ^^^ meta.function.static.arrow entity.name.function -// ^ meta.function.static.arrow keyword.operator.assignment -// ^ meta.function.static.arrow variable.parameter.function -// ^^ meta.function.static.arrow storage.type.function.arrow -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -TTT.ttt = function() {} -//^^^^^^^^^^^^^^^^^^ meta.function.static -//^ meta.function.static entity.name.class -//<- source.js -// ^ meta.function.static keyword.operator.accessor -// ^^^ meta.function.static entity.name.function -// ^ meta.function.static keyword.operator.assignment -// ^^^^^^^^ meta.function.static storage.type.function -// ^ meta.function.static punctuation.definition.parameters.begin -// ^ meta.function.static punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -UUU.uuu = function(z) {} -//^^^^^^^^^^^^^^^^^^^ meta.function.static -//^ meta.function.static entity.name.class -//<- source.js -// ^ meta.function.static keyword.operator.accessor -// ^^^ meta.function.static entity.name.function -// ^ meta.function.static keyword.operator.assignment -// ^^^^^^^^ meta.function.static storage.type.function -// ^ meta.function.static punctuation.definition.parameters.begin -// ^ meta.function.static variable.parameter.function -// ^ meta.function.static punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -VVV.vvv = function vv() {} -//^^^^^^^^^^^^^^^^^^^^^ meta.function.static -//^ meta.function.static entity.name.class -//<- source.js -// ^ meta.function.static keyword.operator.accessor -// ^^^ meta.function.static entity.name.function -// ^ meta.function.static keyword.operator.assignment -// ^^^^^^^^ meta.function.static storage.type.function -// ^^ meta.function.static entity.name.function -// ^ meta.function.static punctuation.definition.parameters.begin -// ^ meta.function.static punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - -WWW.www = function ww(z) {} -//^^^^^^^^^^^^^^^^^^^^^^ meta.function.static -//^ meta.function.static entity.name.class -//<- source.js -// ^ meta.function.static keyword.operator.accessor -// ^^^ meta.function.static entity.name.function -// ^ meta.function.static keyword.operator.assignment -// ^^^^^^^^ meta.function.static storage.type.function -// ^^ meta.function.static entity.name.function -// ^ meta.function.static punctuation.definition.parameters.begin -// ^ meta.function.static variable.parameter.function -// ^ meta.function.static punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end - - -class X extends XX {} -//^^^^^^^^^^^^^^^^^^^ meta.class -//^^^ meta.class storage.type.class -// ^ meta.class entity.name.class -// ^^^^^^^^^^^ meta.class meta.class.extends -// ^^^^^^^ meta.class meta.class.extends storage.type.extends -// ^^ meta.class meta.class.extends variable.other.constant -// ^ meta.class meta.brace.curly.begin -// ^ meta.class meta.brace.curly.end -class Y {} -//^^^^^^^^ meta.class -//^^^ meta.class storage.type.class -// ^ meta.class entity.name.class -// ^ meta.class meta.brace.curly.begin -// ^ meta.class meta.brace.curly.end - - -var node = Relay.QL`node(123) {${Relay.QL`User {address {${fragment}, }, } `} }`; -//^ storage.type -//<- source.js -// ^^^^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^^^^^ meta.property.class variable.other.class -// ^ meta.property.class keyword.operator.accessor -// ^^ meta.property.class variable.other.property.static -// ^^^^^^^^^^^^ string.interpolated -// ^ string.interpolated keyword.other.template.begin -// ^^ keyword.other.substitution.begin -// ^^^^^ meta.property.class variable.other.class -// ^ meta.property.class keyword.operator.accessor -// ^^ meta.property.class variable.other.property.static -// ^^^^^^^^^^^^^^^^ string.interpolated -// ^ string.interpolated keyword.other.template.begin -// ^^ keyword.other.substitution.begin -// ^^^^^^^^ variable.other.readwrite -// ^ keyword.other.substitution.end -// ^^^^^^^^ string.interpolated -// ^ string.interpolated keyword.other.template.end -// ^ keyword.other.substitution.end -// ^^^ string.interpolated -// ^ string.interpolated keyword.other.template.end -// ^ punctuation.terminator.statement diff --git a/Packages/JSX/test/syntax_test_jsx_OLD.js b/Packages/JSX/test/syntax_test_jsx_OLD.js deleted file mode 100644 index 552de44..0000000 --- a/Packages/JSX/test/syntax_test_jsx_OLD.js +++ /dev/null @@ -1,767 +0,0 @@ -// SYNTAX TEST "Packages/babel-sublime/JavaScript (Babel).tmLanguage" - -
-//^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^ meta.jsx comment.block -// ^^ meta.jsx comment.block punctuation.definition.comment.begin -// ^^ meta.jsx comment.block punctuation.definition.comment.end -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^^^^^^^^ meta.jsx comment.block -// ^^ meta.jsx comment.block punctuation.definition.comment.begin -// ^^ meta.jsx comment.block punctuation.definition.comment.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^ meta.jsx comment.block -// ^^ meta.jsx comment.block punctuation.definition.comment.begin -// ^^ meta.jsx comment.block punctuation.definition.comment.end -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^^^^^^^^ meta.jsx comment.block -// ^^ meta.jsx comment.block punctuation.definition.comment.begin -// ^^ meta.jsx comment.block punctuation.definition.comment.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression constant.numeric -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression constant.numeric -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression constant.numeric -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
this.setState({})} /> -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^^^ meta.jsx meta.embedded.expression meta.function.arrow -// ^ meta.jsx meta.embedded.expression meta.function.arrow punctuation.definition.parameters.begin -// ^ meta.jsx meta.embedded.expression meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.jsx meta.embedded.expression meta.function.arrow storage.type.function.arrow -// ^^^^ meta.jsx meta.embedded.expression variable.language.this -// ^ meta.jsx meta.embedded.expression keyword.operator.accessor -// ^^^^^^^^ meta.jsx meta.embedded.expression meta.function-call.method.with-arguments variable.function -// ^ meta.jsx meta.embedded.expression meta.group.braces.round meta.brace.round.begin -// ^ meta.jsx meta.embedded.expression meta.group.braces.round meta.brace.curly.begin -// ^ meta.jsx meta.embedded.expression meta.group.braces.round meta.brace.curly.end -// ^ meta.jsx meta.embedded.expression meta.group.braces.round meta.brace.round.end -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression constant.numeric -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression constant.numeric -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression constant.numeric -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^^ meta.jsx string.quoted -//^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression constant.numeric -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^^^^^^^^ meta.jsx comment.block -// ^^ meta.jsx comment.block punctuation.definition.comment.begin -// ^^ meta.jsx comment.block punctuation.definition.comment.end -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^ meta.jsx comment.block -// ^^ meta.jsx comment.block punctuation.definition.comment.begin -// ^^ meta.jsx comment.block punctuation.definition.comment.end -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^^^^^^^^ meta.jsx comment.block -// ^^ meta.jsx comment.block punctuation.definition.comment.begin -// ^^ meta.jsx comment.block punctuation.definition.comment.end -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^ meta.jsx comment.block -// ^^ meta.jsx comment.block punctuation.definition.comment.begin -// ^^ meta.jsx comment.block punctuation.definition.comment.end -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - - -// tight greater-/less-than operations. - -for (var i=1; i -//^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^ meta.jsx entity.other.attribute-name -// ^^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end -
-//^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end -
-//^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx keyword.operator.assignment -// ^^ meta.jsx meta.tag punctuation.definition.tag.end -
-//^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^ meta.jsx meta.tag punctuation.definition.tag.end -
-//^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^ meta.jsx meta.tag punctuation.definition.tag.end -
-//^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end -
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.end -
-//^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^^^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -// comments between attributes, -// namespaced components, and -// non-alpha chars in tag/attribute names - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^^^^^ meta.jsx comment.block -// ^^ meta.jsx comment.block punctuation.definition.comment.begin -// ^^ meta.jsx comment.block punctuation.definition.comment.end -// ^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^^ meta.jsx meta.embedded.expression variable.language.this -// ^ meta.jsx meta.embedded.expression keyword.operator.accessor -// ^^^^^^^ meta.jsx meta.embedded.expression meta.property.object variable.other.property -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -//^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.tag entity.name.tag -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -//^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^^^^^^^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end -
-//^^^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end - - -/** - * These have always work - */ -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end - {'it\'s with text inside'} -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin -// ^^ meta.jsx meta.embedded.expression string.quoted constant.character.escape -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -
-//^^^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
{'it\'s with text inside'}
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin -// ^^ meta.jsx meta.embedded.expression string.quoted constant.character.escape -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end - {'it\'s with text inside'} -//^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin -// ^^ meta.jsx meta.embedded.expression string.quoted constant.character.escape -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -
-//^^^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
{'it\'s with text inside'}
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin -// ^^ meta.jsx meta.embedded.expression string.quoted constant.character.escape -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end -
-//^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end - {"it's with text inside"} -//^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -
-//^^^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
{"it's with text inside"}
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end - {"it's with text inside"} -//^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx meta.embedded.expression string.quoted -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.begin -// ^ meta.jsx meta.embedded.expression string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -
-//^^^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end - - - -/** - * Fixed - */ -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end - it's with text inside -
-//^^^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
it's with text inside
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end - it's with text inside -
-//^^^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
it's with text inside
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end -
-//^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end - it's with text inside -
-//^^^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
it's with text inside
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end -
-//^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end - it's with text inside -
-//^^^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
it's with text inside
-//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.jsx -//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
it's with text inside
-//^ meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
it's with text inside
-//^ meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end diff --git a/Packages/JSX/test/syntax_test_jsx_invalid_OLD.js b/Packages/JSX/test/syntax_test_jsx_invalid_OLD.js deleted file mode 100644 index 47a719b..0000000 --- a/Packages/JSX/test/syntax_test_jsx_invalid_OLD.js +++ /dev/null @@ -1,231 +0,0 @@ -// SYNTAX TEST "Packages/babel-sublime/JavaScript (Babel).tmLanguage" - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression constant.numeric -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression constant.numeric -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^ meta.jsx entity.other.attribute-name -// ^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^ meta.jsx entity.other.attribute-name -// ^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.jsx meta.embedded.expression constant.numeric -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx keyword.operator.assignment -// ^^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx keyword.operator.assignment -// ^^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx entity.other.attribute-name -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^ meta.jsx keyword.operator.assignment -// ^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx keyword.operator.assignment -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^^^^^ meta.jsx string.quoted -//^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -< > -//<- meta.jsx invalid.illegal.tag.incomplete - -
-//^ meta.jsx meta.tag entity.name.tag -//<- meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^^^^ meta.jsx entity.other.attribute-name -// ^^^^^^^^^ meta.jsx string.quoted -// ^ meta.jsx string.quoted punctuation.definition.string.begin -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^^^^ meta.jsx entity.other.attribute-name -// ^^ meta.jsx meta.tag punctuation.definition.tag.end - -
-//^^^^ keyword.operator.module -//<- source.js -// ^^^^^^^ keyword.control.loop -// ^^^^^^^^^^^^^^^^^^^^ meta.jsx -// ^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^ meta.jsx meta.tag entity.name.tag -// ^^ meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end - -export default React.createClass({ -//^^^^ keyword.operator.module -//<- source.js -// ^^^^^^^ keyword.control.loop -// ^^^^^ meta.function-call.static.with-arguments variable.other.class -// ^ meta.function-call.static.with-arguments keyword.operator.accessor -// ^^^^^^^^^^^ meta.function-call.static.with-arguments variable.function -// ^ meta.group.braces.round meta.brace.round.begin -// ^ meta.brace.curly.begin - - mixins: [InputsMixin], -//^^^^^^ constant.other.object.key string.unquoted.label -// ^ constant.other.object.key punctuation.separator.key-value -// ^ meta.group.braces.square meta.brace.square.begin -// ^^^^^^^^^^^ meta.group.braces.square variable.other.readwrite -// ^ meta.group.braces.square meta.brace.square.end -// ^ meta.delimiter.comma - - submit() { -//^^^^^^ meta.method string.unquoted entity.name.function -// ^ meta.method punctuation.definition.parameters.begin -// ^ meta.method punctuation.definition.parameters.end -// ^ meta.brace.curly.begin - - var {email, question} = this.state; -// ^^^ storage.type -// ^^^^^^^^^^^^^^^^^ meta.group.braces.curly -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^^^^^ meta.group.braces.curly variable.other.readwrite -// ^ meta.group.braces.curly meta.delimiter.comma -// ^^^^^^^^ meta.group.braces.curly variable.other.readwrite -// ^ meta.group.braces.curly meta.brace.curly.end -// ^ keyword.operator.assignment -// ^^^^ variable.language.this -// ^ keyword.operator.accessor -// ^^^^^ meta.property.object variable.other.property -// ^ punctuation.terminator.statement - request -// ^^^^^^^ variable.other.readwrite - - .post(`${API_BASE}/askform`) -// ^ keyword.operator.accessor -// ^^^^ meta.function-call.method.with-arguments variable.function -// ^ meta.group.braces.round meta.brace.round.begin -// ^ meta.group.braces.round string.interpolated keyword.other.template.begin -// ^^ meta.group.braces.round keyword.other.substitution.begin -// ^^^^^^^^ meta.group.braces.round variable.other.constant -// ^ meta.group.braces.round keyword.other.substitution.end -// ^^^^^^^^^ meta.group.braces.round string.interpolated -// ^ meta.group.braces.round string.interpolated keyword.other.template.end -// ^ meta.group.braces.round meta.brace.round.end - .send({email, question}) -// ^ keyword.operator.accessor -// ^^^^ meta.function-call.method.with-arguments variable.function -// ^ meta.group.braces.round meta.brace.round.begin -// ^^^^^^^^^^^^^^^^^ -// ^ meta.brace.curly.begin -// ^^^^^ variable.other.readwrite -// ^ meta.delimiter.comma -// ^^^^^^^^ variable.other.readwrite -// ^ meta.brace.curly.end -// ^ meta.group.braces.round meta.brace.round.end - .end((err, res) => -// ^ keyword.operator.accessor -// ^^^ meta.function-call.method.with-arguments variable.function -// ^ meta.group.braces.round meta.brace.round.begin -// ^^^^^^^^^^^^^ meta.group.braces.round meta.function.arrow -// ^ meta.group.braces.round meta.function.arrow punctuation.definition.parameters.begin -// ^^^ meta.group.braces.round meta.function.arrow variable.parameter.function -// ^ meta.group.braces.round meta.function.arrow punctuation.separator.parameter.function -// ^^^ meta.group.braces.round meta.function.arrow variable.parameter.function -// ^ meta.group.braces.round meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.group.braces.round meta.function.arrow storage.type.function.arrow - this.setState({isValid: !err})); -// ^^^^ meta.group.braces.round variable.language.this -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.round -// ^ meta.group.braces.round keyword.operator.accessor -// ^^^^^^^^ meta.group.braces.round meta.function-call.method.with-arguments variable.function -// ^ meta.group.braces.round meta.group.braces.round meta.brace.round.begin -// ^^^^^^^^^^^^^^^ meta.group.braces.round -// ^ meta.group.braces.round meta.brace.curly.begin -// ^^^^^^^ meta.group.braces.round constant.other.object.key string.unquoted.label -// ^ meta.group.braces.round constant.other.object.key punctuation.separator.key-value -// ^ meta.group.braces.round keyword.operator.logical -// ^^^ meta.group.braces.round variable.other.readwrite -// ^ meta.group.braces.round meta.brace.curly.end -// ^^ meta.group.braces.round meta.brace.round.end -// ^ meta.group.braces.round meta.group.braces.round meta.brace.round.end -// ^ punctuation.terminator.statement - }, -//^ meta.brace.curly.end -// ^ meta.delimiter.comma - - - 'key//1': function() {}, -//^^^^^^^^^^^^^^^^^^^^ meta.function.json -//^ meta.function.json string.quoted punctuation.definition.string.begin -// ^^^^^^ meta.function.json string.quoted entity.name.function -// ^ meta.function.json string.quoted punctuation.definition.string.end -// ^ meta.function.json punctuation.separator.key-value -// ^^^^^^^^ meta.function.json storage.type.function -// ^ meta.function.json punctuation.definition.parameters.begin -// ^ meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -// ^ meta.delimiter.comma - - 'key/***/1': function() {}, -//^^^^^^^^^^^^^^^^^^^^^^^ meta.function.json -//^ meta.function.json string.quoted punctuation.definition.string.begin -// ^^^^^^^^^ meta.function.json string.quoted entity.name.function -// ^ meta.function.json string.quoted punctuation.definition.string.end -// ^ meta.function.json punctuation.separator.key-value -// ^^^^^^^^ meta.function.json storage.type.function -// ^ meta.function.json punctuation.definition.parameters.begin -// ^ meta.function.json punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin -// ^ meta.group.braces.curly meta.brace.curly.end -// ^ meta.delimiter.comma - - - render() { -//^^^^^^ meta.method string.unquoted entity.name.function -// ^ meta.method punctuation.definition.parameters.begin -// ^ meta.method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin - var {email} = this.state; -// ^^^ meta.group.braces.curly storage.type -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin -// ^^^^^ meta.group.braces.curly meta.group.braces.curly variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly keyword.operator.assignment -// ^^^^ meta.group.braces.curly variable.language.this -// ^ meta.group.braces.curly keyword.operator.accessor -// ^^^^^ meta.group.braces.curly meta.property.object variable.other.property -// ^ meta.group.braces.curly punctuation.terminator.statement - var list = this.props.secondary.map(pic => )} -// ^^^ meta.group.braces.curly storage.type -// ^^^^ meta.group.braces.curly variable.other.readwrite -// ^ meta.group.braces.curly keyword.operator.assignment -// ^^^^ meta.group.braces.curly variable.language.this -// ^ meta.group.braces.curly keyword.operator.accessor -// ^^^^^ meta.group.braces.curly meta.property.object variable.other.property -// ^ meta.group.braces.curly keyword.operator.accessor -// ^^^^^^^^^ meta.group.braces.curly meta.property.object variable.other.property -// ^ meta.group.braces.curly keyword.operator.accessor -// ^^^ meta.group.braces.curly meta.function-call.method.with-arguments variable.function -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin -// ^^^^^^ meta.group.braces.curly meta.group.braces.round meta.function.arrow -// ^^^ meta.group.braces.curly meta.group.braces.round meta.function.arrow variable.parameter.function -// ^^ meta.group.braces.curly meta.group.braces.round meta.function.arrow storage.type.function.arrow -// ^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.group.braces.round meta.jsx -// ^ meta.group.braces.curly meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.group.braces.curly meta.group.braces.round meta.jsx meta.tag entity.name.tag -// ^^^ meta.group.braces.curly meta.group.braces.round meta.jsx entity.other.attribute-name -// ^ meta.group.braces.curly meta.group.braces.round meta.jsx keyword.operator.assignment -// ^ meta.group.braces.curly meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^ meta.group.braces.curly meta.group.braces.round meta.jsx meta.embedded.expression variable.other.readwrite -// ^ meta.group.braces.curly meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^ meta.group.braces.curly meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.end -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end -// ^ meta.group.braces.curly meta.brace.curly.end - var multilineAttr = -// ^ meta.jsx string.quoted punctuation.definition.string.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end - - return ( -// ^^^^^^ keyword.control.flow -// ^ meta.group.braces.round meta.brace.round.begin -
test
}> -// ^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.group.braces.round meta.jsx meta.tag entity.name.tag -// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^ meta.group.braces.round meta.jsx meta.embedded.expression keyword.operator.spread -// ^^^^ meta.group.braces.round meta.jsx meta.embedded.expression variable.language.this -// ^ meta.group.braces.round meta.jsx meta.embedded.expression keyword.operator.accessor -// ^^^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.property.object variable.other.property -// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^^^^^^^ meta.group.braces.round meta.jsx entity.other.attribute-name -// ^ meta.group.braces.round meta.jsx keyword.operator.assignment -// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^^^^^^^^^^^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx -// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx meta.tag entity.name.tag -// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx meta.tag entity.name.tag -// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.jsx meta.tag punctuation.definition.tag.end -// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.end - -// ^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^ meta.group.braces.round meta.jsx meta.tag entity.name.tag -// ^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^^^ meta.group.braces.round meta.jsx meta.tag entity.name.tag -// ^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.end - - {list} -// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^^ meta.group.braces.round meta.jsx meta.embedded.expression variable.other.readwrite -// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.end - {[in an array]} -// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.brace.square.begin -// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx -// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx meta.tag entity.name.tag -// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx meta.tag punctuation.definition.tag.end -// ^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx meta.tag entity.name.tag -// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.jsx meta.tag punctuation.definition.tag.end -// ^ meta.group.braces.round meta.jsx meta.embedded.expression meta.group.braces.square meta.brace.square.end -// ^ meta.group.braces.round meta.jsx meta.embedded.expression punctuation.section.embedded.end - - -// ^^^^^^^^ meta.group.braces.round meta.jsx entity.other.attribute-name -// ^^^^^^^ meta.group.braces.round meta.jsx comment.block -// ^^ meta.group.braces.round meta.jsx comment.block punctuation.definition.comment.begin -// ^^ meta.group.braces.round meta.jsx comment.block punctuation.definition.comment.end -// ^^ meta.group.braces.round meta.jsx meta.tag punctuation.definition.tag.end - -
- ); - } -}); - - -export class Counter extends React.Component { -//^^^^ keyword.operator.module -//<- source.js -// ^^^^^ storage.type.class -// ^^^^^^^ entity.name.class -// ^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.extends -// ^^^^^^^ meta.class.extends storage.type.extends -// ^^^^^ meta.class.extends meta.property.class variable.other.class -// ^ meta.class.extends meta.property.class keyword.operator.accessor -// ^^^^^^^^^ meta.class.extends meta.property.class variable.other.property.static -// ^ meta.brace.curly.begin - static propTypes = { initialCount: React.PropTypes.number }; -//^^^^^^ storage.modifier -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.property -// ^^^^^^^^^ meta.class.property variable.other.property -// ^ meta.class.property keyword.operator.assignment -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.property meta.group.braces.curly -// ^ meta.class.property meta.group.braces.curly meta.brace.curly.begin -// ^^^^^^^^^^^^ meta.class.property meta.group.braces.curly constant.other.object.key string.unquoted.label -// ^ meta.class.property meta.group.braces.curly constant.other.object.key punctuation.separator.key-value -// ^^^^^ meta.class.property meta.group.braces.curly meta.property.class variable.other.class -// ^ meta.class.property meta.group.braces.curly meta.property.class keyword.operator.accessor -// ^^^^^^^^^ meta.class.property meta.group.braces.curly meta.property.class variable.other.property.static -// ^ meta.class.property meta.group.braces.curly keyword.operator.accessor -// ^^^^^^ meta.class.property meta.group.braces.curly meta.property.object variable.other.property -// ^ meta.class.property meta.group.braces.curly meta.brace.curly.end - static defaultProps = { initialCount: 0 }; -//^^^^^^ storage.modifier -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.property -// ^^^^^^^^^^^^ meta.class.property variable.other.property -// ^ meta.class.property keyword.operator.assignment -// ^^^^^^^^^^^^^^^^^^^ meta.class.property meta.group.braces.curly -// ^ meta.class.property meta.group.braces.curly meta.brace.curly.begin -// ^^^^^^^^^^^^ meta.class.property meta.group.braces.curly constant.other.object.key string.unquoted.label -// ^ meta.class.property meta.group.braces.curly constant.other.object.key punctuation.separator.key-value -// ^ meta.class.property meta.group.braces.curly constant.numeric -// ^ meta.class.property meta.group.braces.curly meta.brace.curly.end - static childContextTypes = () => { -//^^^^^^ storage.modifier -// ^^^^^^^^^^^^^^^^^ meta.class.property variable.other.property -// ^ meta.class.property keyword.operator.assignment -// ^^^^^ meta.class.property meta.function.arrow -// ^ meta.class.property meta.function.arrow punctuation.definition.parameters.begin -// ^ meta.class.property meta.function.arrow punctuation.definition.parameters.end -// ^^ meta.class.property meta.function.arrow storage.type.function.arrow -// ^ meta.class.property meta.group.braces.curly meta.brace.curly.begin - return { -// ^^^^^^ meta.class.property meta.group.braces.curly keyword.control.flow -// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.brace.curly.begin - - app: React.PropTypes.instanceOf(App).isRequired -// ^^^ meta.class.property meta.group.braces.curly meta.group.braces.curly constant.other.object.key string.unquoted.label -// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly constant.other.object.key punctuation.separator.key-value -// ^^^^^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.property.class variable.other.class -// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.property.class keyword.operator.accessor -// ^^^^^^^^^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.property.class variable.other.property.static -// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly keyword.operator.accessor -// ^^^^^^^^^^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.function-call.method.with-arguments variable.function -// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.group.braces.round meta.brace.round.begin -// ^^^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.group.braces.round variable.other.readwrite -// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.group.braces.round meta.brace.round.end -// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly keyword.operator.accessor -// ^^^^^^^^^^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.property.object variable.other.property - } -// ^ meta.class.property meta.group.braces.curly meta.group.braces.curly meta.brace.curly.end - }; -//^ meta.class.property meta.group.braces.curly meta.brace.curly.end - getChildContext = makeGetChildContext(); -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.property -//^^^^^^^^^^^^^^^ meta.class.property variable.other.property -// ^ meta.class.property keyword.operator.assignment -// ^^^^^^^^^^^^^^^^^^^ meta.class.property meta.function-call.without-arguments variable.function -// ^^ meta.class.property meta.function-call.without-arguments meta.group.braces.round.function.arguments - state = { count: this.props.initialCount }; -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.property -//^^^^^ meta.class.property variable.other.property -// ^ meta.class.property keyword.operator.assignment -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.class.property meta.group.braces.curly -// ^ meta.class.property meta.group.braces.curly meta.brace.curly.begin -// ^^^^^ meta.class.property meta.group.braces.curly constant.other.object.key string.unquoted.label -// ^ meta.class.property meta.group.braces.curly constant.other.object.key punctuation.separator.key-value -// ^^^^ meta.class.property meta.group.braces.curly variable.language.this -// ^ meta.class.property meta.group.braces.curly keyword.operator.accessor -// ^^^^^ meta.class.property meta.group.braces.curly meta.property.object variable.other.property -// ^ meta.class.property meta.group.braces.curly keyword.operator.accessor -// ^^^^^^^^^^^^ meta.class.property meta.group.braces.curly meta.property.object variable.other.property -// ^ meta.class.property meta.group.braces.curly meta.brace.curly.end - tick() { -//^^^^ meta.class-method string.unquoted entity.name.function -// ^ meta.class-method punctuation.definition.parameters.begin -// ^ meta.class-method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin - this.setState({ count: this.state.count + 1 }); -// ^^^^ meta.group.braces.curly variable.language.this -// ^ meta.group.braces.curly keyword.operator.accessor -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly -// ^^^^^^^^ meta.group.braces.curly meta.function-call.method.with-arguments variable.function -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly -// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly meta.brace.curly.begin -// ^^^^^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly constant.other.object.key string.unquoted.label -// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly constant.other.object.key punctuation.separator.key-value -// ^^^^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly variable.language.this -// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly keyword.operator.accessor -// ^^^^^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly meta.property.object variable.other.property -// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly keyword.operator.accessor -// ^^^^^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly meta.property.object variable.other.property -// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly keyword.operator.arithmetic -// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly constant.numeric -// ^ meta.group.braces.curly meta.group.braces.round meta.group.braces.curly meta.brace.curly.end -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.end -// ^ meta.group.braces.curly punctuation.terminator.statement - } -//^ meta.group.braces.curly meta.brace.curly.end - render() { -//^^^^^^ meta.class-method string.unquoted entity.name.function -// ^ meta.class-method punctuation.definition.parameters.begin -// ^ meta.class-method punctuation.definition.parameters.end -// ^ meta.group.braces.curly meta.brace.curly.begin - return ( -// ^^^^^^ meta.group.braces.curly keyword.control.flow -// ^ meta.group.braces.curly meta.group.braces.round meta.brace.round.begin -
-// ^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^^^^^^^ meta.jsx entity.other.attribute-name -// ^ meta.jsx keyword.operator.assignment -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^^ meta.jsx meta.embedded.expression variable.language.this -// ^ meta.jsx meta.embedded.expression keyword.operator.accessor -// ^^^^ meta.jsx meta.embedded.expression meta.property.object variable.other.property -// ^ meta.jsx meta.embedded.expression keyword.operator.accessor -// ^^^^ meta.jsx meta.embedded.expression meta.function-call.method.with-arguments variable.function -// ^ meta.jsx meta.embedded.expression meta.group.braces.round meta.brace.round.begin -// ^^^^ meta.jsx meta.embedded.expression meta.group.braces.round variable.language.this -// ^ meta.jsx meta.embedded.expression meta.group.braces.round meta.brace.round.end -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -// ^ meta.jsx meta.tag punctuation.definition.tag.end - Clicks: {this.state.count} -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.begin -// ^^^^ meta.jsx meta.embedded.expression variable.language.this -// ^ meta.jsx meta.embedded.expression keyword.operator.accessor -// ^^^^^ meta.jsx meta.embedded.expression meta.property.object variable.other.property -// ^ meta.jsx meta.embedded.expression keyword.operator.accessor -// ^^^^^ meta.jsx meta.embedded.expression meta.property.object variable.other.property -// ^ meta.jsx meta.embedded.expression punctuation.section.embedded.end -
-// ^^ meta.jsx meta.tag punctuation.definition.tag.begin -// ^^^ meta.jsx meta.tag entity.name.tag -// ^ meta.jsx meta.tag punctuation.definition.tag.end - ); -// ^ meta.brace.round.end -// ^ meta.group.braces.curly punctuation.terminator.statement - } -//^ meta.group.braces.curly meta.brace.curly.end -} -//<- meta.class meta.brace.curly.end diff --git a/Packages/JSX/test/syntax_test_relational_OLD.js b/Packages/JSX/test/syntax_test_relational_OLD.js deleted file mode 100644 index 287954a..0000000 --- a/Packages/JSX/test/syntax_test_relational_OLD.js +++ /dev/null @@ -1,289 +0,0 @@ -// SYNTAX TEST "Packages/babel-sublime/JavaScript (Babel).tmLanguage" - -var a = b -//^ storage.type -//<- source.js -// ^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^ variable.other.readwrite -// ^ keyword.operator.relational -// ^^^ variable.other.readwrite -// ^^^^^^^^^^^ comment.block -// ^^ comment.block punctuation.definition.comment.begin -// ^^ comment.block punctuation.definition.comment.end -// ^^^^^ string.regexp -// ^ string.regexp punctuation.definition.string.begin - -/ -//<- string.regexp punctuation.definition.string.end - -var a = b -//^ storage.type -//<- source.js -// ^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^ variable.other.readwrite -// ^ keyword.operator.relational -// ^^^ variable.other.readwrite -// ^ keyword.operator.arithmetic -// ^ keyword.operator.relational - -var a = b -//^ storage.type -//<- source.js -// ^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^ variable.other.readwrite -// ^ keyword.operator.relational -// ^^^ variable.other.readwrite -// ^ keyword.operator.arithmetic -// ^ keyword.operator.relational - -var a = b -//^ storage.type -//<- source.js -// ^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^ variable.other.readwrite -// ^ keyword.operator.relational -// ^^^ variable.other.readwrite -// ^ keyword.operator.arithmetic -// ^^^ variable.other.readwrite -// ^ keyword.operator.arithmetic -// ^ keyword.operator.relational - -var a = b -//^ storage.type -//<- source.js -// ^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^ variable.other.readwrite -// ^ keyword.operator.relational -// ^^^ variable.other.readwrite -// ^ keyword.operator.arithmetic -// ^^^ variable.other.readwrite -// ^ keyword.operator.arithmetic -// ^ keyword.operator.relational - -var a = b -//^ storage.type -//<- source.js -// ^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^ variable.other.readwrite -// ^ keyword.operator.relational -// ^^^^^^^ variable.other.readwrite -// ^ keyword.operator.arithmetic -// ^ keyword.operator.relational - -var a = b -//^ storage.type -//<- source.js -// ^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^ variable.other.readwrite -// ^ keyword.operator.relational -// ^^^ variable.other.readwrite -// ^ keyword.operator.arithmetic -// ^^^ variable.other.readwrite -// ^ keyword.operator.arithmetic -// ^ keyword.operator.relational - -var a = b -//^ storage.type -//<- source.js -// ^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^ variable.other.readwrite -// ^ keyword.operator.relational -// ^^^ variable.other.object variable.other.object -// ^ keyword.operator.accessor -// ^^^ meta.property.object variable.other.property -// ^ keyword.operator.arithmetic -// ^ keyword.operator.relational - -var a = b -//^ storage.type -//<- source.js -// ^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^ variable.other.readwrite -// ^ keyword.operator.relational -// ^^^ variable.other.object variable.other.object -// ^ keyword.operator.accessor -// ^^^ meta.property.object variable.other.property -// ^^^^^^^^^^^ comment.block -// ^^ comment.block punctuation.definition.comment.begin -// ^^ comment.block punctuation.definition.comment.end -// ^^^^^ string.regexp -// ^ string.regexp punctuation.definition.string.begin - -/ -//<- string.regexp punctuation.definition.string.end - -var a = b -//^ storage.type -//<- source.js -// ^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^ variable.other.readwrite -// ^ keyword.operator.relational -// ^^^ variable.other.readwrite -// ^ keyword.operator.arithmetic -// ^^^^^ string.regexp -// ^ string.regexp punctuation.definition.string.begin - -/ -//<- string.regexp punctuation.definition.string.end - -var a = b -//^ storage.type -//<- source.js -// ^ variable.other.readwrite -// ^ keyword.operator.assignment -// ^ variable.other.readwrite -// ^ keyword.operator.relational -// ^^^ variable.other.object variable.other.object -// ^ keyword.operator.accessor -// ^^^^ string.regexp -// ^ string.regexp punctuation.definition.string.begin diff --git a/Packages/JSX/test/syntax_test_styles.js b/Packages/JSX/test/syntax_test_styles.js deleted file mode 100644 index 53728aa..0000000 --- a/Packages/JSX/test/syntax_test_styles.js +++ /dev/null @@ -1,96 +0,0 @@ -// SYNTAX TEST "JavaScript (Babel).tmLanguage" - -styled.h1`color: #ffcc00;` -//^^^^^^^^^^^^^^^^^^^^^^^^ meta.styled-components -//^^^^ variable.other.object -// ^ punctuation.accessor -// ^^ variable.function.tagged-template -// ^ punctuation.definition.string.template.begin -// ^^^^^^^^^^^^^^^ source.css.embedded -// ^^^^^^^^^^^^^^^ meta.property-list.css -// ^ punctuation.definition.string.template.end - - styled.h1`` -// ^^^^^^^^^^^ meta.styled-components -//^^ -meta.styled-components -// ^^ -meta.styled-components - -styled(Foo)`color: #ffcc00;` -//^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.styled-components -//^^^^^^^^^ meta.function-call.with-arguments -// ^^^^^^^^^^^^^^^^^ -meta.function-call.with-arguments -//^^^^ variable.function -// ^^^^^ meta.group -// ^ punctuation.definition.group.begin -// ^^^ variable.other.readwrite -// ^ punctuation.definition.group.end -// ^ punctuation.definition.string.template.begin -// ^^^^^^^^^^^^^^^ source.css.embedded -// ^^^^^^^^^^^^^^^ meta.property-list.css -// ^ punctuation.definition.string.template.end - - styled(Foo)`` -// ^^^^^^^^^^^^^ meta.styled-components -//^^ -meta.styled-components -// ^^ -meta.styled-components - -styled(Foo.bar())`color: #ffcc00;` -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.styled-components -//^^^^^^^^^^^^^^^ meta.function-call.with-arguments -// ^^^^^^^^^^^^^^^^^ -meta.function-call.with-arguments -//^^^^ variable.function -// ^^^^^^^^^^^ meta.group -// ^ punctuation.definition.group.begin -// ^^^ variable.other.class -// ^ keyword.operator.accessor -// ^^^ variable.function -// ^ punctuation.definition.group.end -// ^ punctuation.definition.string.template.begin -// ^^^^^^^^^^^^^^^ source.css.embedded -// ^^^^^^^^^^^^^^^ meta.property-list.css -// ^ punctuation.definition.string.template.end - - styled(Foo.bar())`` -// ^^^^^^^^^^^^^^^^^^^ meta.styled-components -//^^ -meta.styled-components -// ^^ -meta.styled-components - -styled('div')`color: #ffcc00;` -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.styled-components -//^^^^^^^^^^^ meta.function-call.with-arguments -// ^^^^^^^^^^^^^^^^^ -meta.function-call.with-arguments -//^^^^ variable.function -// ^^^^^^^ meta.group -// ^ punctuation.definition.group.begin -// ^^^^^ string.quoted -// ^ punctuation.definition.group.end -// ^ punctuation.definition.string.template.begin -// ^^^^^^^^^^^^^^^ source.css.embedded -// ^^^^^^^^^^^^^^^ meta.property-list.css -// ^ punctuation.definition.string.template.end - -injectGlobal`color: #ffcc00;` -//^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.styled-components -//^^^^^^^^^ variable.function.tagged-template -// ^ punctuation.definition.string.template.begin -// ^^^^^^^^^^^^^^^ source.css.embedded -// ^^^^^^^^^^^^^^^ meta.property-list.css -// ^ punctuation.definition.string.template.end - - injectGlobal`` -// ^^^^^^^^^^^^^^ meta.styled-components -//^^ -meta.styled-components -// ^^ -meta.styled-components - -keyframes`0%{color: red;} 50%{color: blue;}` -//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.styled-components -//^^^^^^^ variable.function.tagged-template -// ^ punctuation.definition.string.template.begin -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ source.css.embedded -// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.property-list.css -// ^ punctuation.definition.string.template.end - - keyframes`` -// ^^^^^^^^^^^ meta.styled-components -//^^ -meta.styled-components -// ^^ -meta.styled-components From 274332191864242c7cf648b9f229590eee236672 Mon Sep 17 00:00:00 2001 From: Matthias Date: Mon, 13 May 2019 20:25:44 -0700 Subject: [PATCH 3/5] Convert to .sublime-syntax With sublime_syntax_convertor, convert .tmLanguage files for JSX to .sublime-syntax. --- .../JSX/JavaScript (Babel).sublime-syntax | 1288 +++++++++++++++++ Packages/JSX/Styled Components.sublime-syntax | 188 +++ 2 files changed, 1476 insertions(+) create mode 100644 Packages/JSX/JavaScript (Babel).sublime-syntax create mode 100644 Packages/JSX/Styled Components.sublime-syntax diff --git a/Packages/JSX/JavaScript (Babel).sublime-syntax b/Packages/JSX/JavaScript (Babel).sublime-syntax new file mode 100644 index 0000000..e3e3fcc --- /dev/null +++ b/Packages/JSX/JavaScript (Babel).sublime-syntax @@ -0,0 +1,1288 @@ +%YAML 1.2 +--- +# http://www.sublimetext.com/docs/3/syntax.html +name: JavaScript (Babel) +file_extensions: + - js + - jsx + - babel + - es6 +first_line_match: ^#!\s*/.*\b(node|js)$\n? +scope: source.js +contexts: + main: + - include: core + brackets: + - include: round-brackets + - include: square-brackets + - include: curly-brackets + class-method-definition: + - match: '(@@[_$a-zA-Z][$\w]*|static|return)(?=\s*[<(])|(?=\s*<)' + captures: + 1: keyword.operator.flowtype.js + push: + - meta_scope: meta.short-method.flowtype.js + - match: '(?=\s*[;{])' + pop: true + - include: flowtype-polymorph + - include: function-declaration-parameters + - include: flowtype-annotation + - include: comments + - include: curly-brackets + - match: '(?<=[]"''])\s*(?=[<(])' + push: + - meta_scope: meta.class-method.computed.js + - match: '(?=\s*[;{])' + pop: true + - include: flowtype-polymorph + - include: function-declaration-parameters + - include: flowtype-annotation + - include: comments + - include: curly-brackets + - match: |- + (?x) + ((?>get|set)\s+) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + )(?=\s*[<(]) + captures: + 1: storage.type.js + 2: string.quoted.js + 3: punctuation.definition.string.begin.js + 4: entity.name.function.js + 5: punctuation.definition.string.end.js + 6: string.quoted.js + 7: punctuation.definition.string.begin.js + 8: entity.name.function.js + 9: punctuation.definition.string.end.js + 10: string.unquoted.js + 11: entity.name.function.js + push: + - meta_scope: meta.class-accessor.js + - match: '(?=\s*[;{])' + pop: true + - include: flowtype-polymorph + - include: function-declaration-parameters + - include: flowtype-annotation + - include: comments + - include: curly-brackets + - match: |- + (?x) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + )(?=\s*[<(]) + captures: + 1: string.quoted.js + 2: punctuation.definition.string.begin.js + 3: entity.name.function.js + 4: punctuation.definition.string.end.js + 5: string.quoted.js + 6: punctuation.definition.string.begin.js + 7: entity.name.function.js + 8: punctuation.definition.string.end.js + 9: string.unquoted.js + 10: entity.name.function.js + push: + - meta_scope: meta.class-method.js + - match: '(?=\s*[;{])' + pop: true + - include: flowtype-polymorph + - include: function-declaration-parameters + - include: flowtype-annotation + - include: comments + - include: curly-brackets + class-method-storage: + - match: (?static|declare)\b + scope: storage.modifier.js + - match: (?) + scope: comment.block.html.js + captures: + 0: punctuation.definition.comment.js + - match: (//).*$\n? + scope: comment.line.double-slash.js + captures: + 1: punctuation.definition.comment.js + - match: ^(#!).*$\n? + scope: comment.line.shebang.js + captures: + 1: punctuation.definition.comment.js + core: + - include: literal-function-labels + - include: literal-arrow-function-labels + - include: literal-labels + - include: literal-for + - include: literal-switch + - include: styled-components + - include: graphql + - include: expression + - include: literal-punctuation + curly-brackets: + - match: "{" + captures: + 0: meta.brace.curly.begin.js + push: + - meta_scope: meta.group.braces.curly.js + - match: "}" + captures: + 0: meta.brace.curly.end.js + pop: true + - include: main + es7-decorators: + - match: |- + (?x) + (@)([_$a-zA-Z][$\w]*)\b + scope: tag.decorator.js + captures: + 1: punctuation.definition.tag.js + 2: entity.name.tag.js + expression: + - include: merge-conflits + - include: literal-regexp + - include: literal-jsx + - include: es7-decorators + - include: support-class + - include: support-other + - include: literal-function + - include: literal-arrow-function + - include: literal-prototype + - include: literal-keywords + - include: literal-method + - include: literal-module + - include: literal-class + - include: flowtype-declaration + - include: literal-number + - include: literal-template-string + - include: literal-string + - include: literal-language-constant + - include: literal-language-variable + - include: literal-constructor + - include: literal-method-call + - include: literal-function-call + - include: comments + - include: brackets + - include: literal-operators + - include: literal-variable + flowtype-annotation: + - match: (?:(\?)\s*)?(:) + captures: + 1: keyword.operator.flowtype.optional.js + 2: keyword.operator.flowtype.annotation.js + push: + - meta_scope: meta.flowtype.annotation.js + - include: flowtype-tokens + - match: (?=\S) + pop: true + flowtype-brackets: + - match: "{" + captures: + 0: punctuation.section.flowtype.begin.js + push: + - match: "}" + captures: + 0: punctuation.section.flowtype.end.js + pop: true + - include: flowtype-tokens + flowtype-declaration: + - match: (?" + captures: + 0: punctuation.section.flowtype.end.js + pop: true + - include: flowtype-tokens + flowtype-tokens: + - match: '(?<=[:?|&=])(?=\s*{)' + push: + - match: "(?<=})" + pop: true + - include: flowtype-brackets + - match: '\s*([|&])\s*' + scope: meta.flowtype.set.js + captures: + 1: keyword.operator.flowtype.other.js + - match: '[*:?&|.]|\.\.\.|\b(typeof)\b' + scope: keyword.operator.flowtype.other.js + - match: < + captures: + 0: punctuation.section.flowtype.begin.js + push: + - match: ">" + captures: + 0: punctuation.section.flowtype.end.js + pop: true + - include: flowtype-tokens + - match: '\[' + captures: + 0: punctuation.section.flowtype.begin.js + push: + - match: '\]' + captures: + 0: punctuation.section.flowtype.end.js + pop: true + - include: flowtype-tokens + - match: \( + captures: + 0: punctuation.section.flowtype.begin.js + push: + - match: \) + captures: + 0: punctuation.section.flowtype.end.js + pop: true + - include: flowtype-tokens + - match: "=>" + captures: + 0: keyword.operator.flowtype.js + push: + - meta_scope: meta.flowtype.function.js + - match: "(?<=}|[_$a-zA-Z])" + pop: true + - include: flowtype-brackets + - include: flowtype-identifier + - include: comments + - include: flowtype-identifier + - include: literal-string + - include: comments + function-declaration-parameters: + - match: \( + captures: + 0: punctuation.definition.parameters.begin.js + push: + - match: \) + captures: + 0: punctuation.definition.parameters.end.js + pop: true + - include: comments + - include: flowtype-annotation + - match: (?" + captures: + 0: meta.tag.jsx punctuation.definition.tag.end.jsx + push: + - match: (?=)|(/>) + captures: + 1: meta.tag.jsx punctuation.definition.tag.begin.jsx + 2: meta.tag.jsx entity.name.tag.jsx + 3: meta.tag.jsx punctuation.definition.tag.end.jsx + 4: meta.tag.jsx punctuation.definition.tag.end.jsx + pop: true + - include: jsx-tag-end + - include: jsx-attributes + - match: < + scope: invalid.illegal.tag.incomplete.jsx + literal-arrow-function: + - match: |- + (?x) + (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? + (?:\b(async)\s+)? + (?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) + captures: + 1: entity.name.function.js + 2: keyword.operator.assignment.js + 3: storage.type.js + push: + - meta_scope: meta.function.arrow.js + - match: (?<=\))\s*(=>) + captures: + 1: storage.type.function.arrow.js + pop: true + - include: function-declaration-parameters + - match: |- + (?x) + (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? + (?:(async)\s+)? + \b([_$a-zA-Z][$\w]*)\s*(=>) + scope: meta.function.arrow.js + captures: + 1: entity.name.function.js + 2: keyword.operator.assignment.js + 3: storage.type.js + 4: variable.parameter.function.js + 5: storage.type.function.arrow.js + - match: |- + (?x) + (\b_?[A-Z][$\w]*)? + (\.)(prototype) + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(async)? + \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) + captures: + 1: entity.name.class.js + 2: keyword.operator.accessor.js + 3: variable.language.prototype.js + 4: keyword.operator.accessor.js + 5: entity.name.function.js + 6: keyword.operator.assignment.js + 7: storage.type.js + push: + - meta_scope: meta.prototype.function.arrow.js + - match: (?<=\))\s*(=>) + captures: + 1: storage.type.function.arrow.js + pop: true + - include: function-declaration-parameters + - match: |- + (?x) + (\b_?[A-Z][$\w]*)? + (\.)(prototype) + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(async)? + \s*\b([_$a-zA-Z][$\w]*)\s*(=>) + scope: meta.prototype.function.arrow.js + captures: + 1: entity.name.class.js + 2: keyword.operator.accessor.js + 3: variable.language.prototype.js + 4: keyword.operator.accessor.js + 5: entity.name.function.js + 6: keyword.operator.assignment.js + 7: storage.type.js + 8: variable.parameter.function.js + 9: storage.type.function.arrow.js + - match: |- + (?x) + (\b_?[A-Z][$\w]*)? + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(async)? + \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) + captures: + 1: entity.name.class.js + 2: keyword.operator.accessor.js + 3: entity.name.function.js + 4: keyword.operator.assignment.js + 5: storage.type.js + push: + - meta_scope: meta.function.static.arrow.js + - match: (?<=\))\s*(=>) + captures: + 1: storage.type.function.arrow.js + pop: true + - include: function-declaration-parameters + - match: |- + (?x) + (\b_?[A-Z][$\w]*)? + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(async)? + \s*\b([_$a-zA-Z][$\w]*)\s*(=>) + scope: meta.function.static.arrow.js + captures: + 1: entity.name.class.js + 2: keyword.operator.accessor.js + 3: entity.name.function.js + 4: keyword.operator.assignment.js + 5: storage.type.js + 6: variable.parameter.function.js + 7: storage.type.function.arrow.js + literal-arrow-function-labels: + - match: |- + (?x) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + ) + \s*(:) + \s*(?:\b(async)\s+)? + \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) + captures: + 1: string.quoted.js + 2: punctuation.definition.string.begin.js + 3: entity.name.function.js + 4: punctuation.definition.string.end.js + 5: string.quoted.js + 6: punctuation.definition.string.begin.js + 7: entity.name.function.js + 8: punctuation.definition.string.end.js + 9: string.unquoted.js + 10: entity.name.function.js + 11: punctuation.separator.key-value.js + 12: storage.type.js + push: + - meta_scope: meta.function.json.arrow.js + - match: (?<=\))\s*(=>) + captures: + 1: storage.type.function.arrow.js + pop: true + - include: function-declaration-parameters + - match: |- + (?x) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + ) + \s*(:) + \s*(?:\b(async)\s+)? + \s*\b([_$a-zA-Z][$\w]*)\s*(=>) + scope: meta.function.json.arrow.js + captures: + 1: string.quoted.js + 2: punctuation.definition.string.begin.js + 3: entity.name.function.js + 4: punctuation.definition.string.end.js + 5: string.quoted.js + 6: punctuation.definition.string.begin.js + 7: entity.name.function.js + 8: punctuation.definition.string.end.js + 9: string.unquoted.js + 10: entity.name.function.js + 11: punctuation.separator.key-value.js + 12: storage.type.js + 13: variable.parameter.function.js + 14: storage.type.function.arrow.js + literal-class: + - match: (?\s*(\*)|(?=[\s(<])) + \s*([_$a-zA-Z][$\w]*)? + captures: + 1: entity.name.function.js + 2: keyword.operator.assignment.js + 3: storage.type.js + 4: storage.type.function.js + 5: keyword.generator.asterisk.js + 6: entity.name.function.js + push: + - meta_scope: meta.function.js + - match: (?<=\)) + pop: true + - include: flowtype-polymorph + - include: function-declaration-parameters + - match: |- + (?x) + (\b_?[A-Z][$\w]*)? + (\.)(prototype) + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(?:(async)\s+)? + \s*(function)(?>\s*(\*)|(?=[\s(<])) + \s*([_$a-zA-Z][$\w]*)?\s* + captures: + 1: entity.name.class.js + 2: keyword.operator.accessor.js + 3: variable.language.prototype.js + 4: keyword.operator.accessor.js + 5: entity.name.function.js + 6: keyword.operator.assignment.js + 7: storage.type.js + 8: storage.type.function.js + 9: keyword.generator.asterisk.js + 10: entity.name.function.js + push: + - meta_scope: meta.function.prototype.js + - match: (?<=\)) + pop: true + - include: flowtype-polymorph + - include: function-declaration-parameters + - match: |- + (?x) + (\b_?[A-Z][$\w]*)? + (\.)([_$a-zA-Z][$\w]*) + \s*(=) + \s*(?:(async)\s+)? + \s*(function)(?>\s*(\*)|(?=[\s(<])) + \s*([_$a-zA-Z][$\w]*)?\s* + captures: + 1: entity.name.class.js + 2: keyword.operator.accessor.js + 3: entity.name.function.js + 4: keyword.operator.assignment.js + 5: storage.type.js + 6: storage.type.function.js + 7: keyword.generator.asterisk.js + 8: entity.name.function.js + push: + - meta_scope: meta.function.static.js + - match: (?<=\)) + pop: true + - include: flowtype-polymorph + - include: function-declaration-parameters + literal-function-call: + - match: '([_$a-zA-Z][$\w]*)\s*(\(\s*\))' + scope: meta.function-call.without-arguments.js + captures: + 1: variable.function.js + 2: meta.group.braces.round.function.arguments.js + - match: '([_$a-zA-Z][$\w]*)\s*(?=\()' + scope: meta.function-call.with-arguments.js + captures: + 1: variable.function.js + - match: '([_$a-zA-Z][$\w]*)\s*(?=`)' + scope: meta.function-call.tagged-template.js + captures: + 1: variable.function.js + literal-function-labels: + - match: |- + (?x) + (?> + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + ) + \s*(:) + \s*(?:\b(async)\s+)? + \s*(function)(?>\s*(\*)|(?=[\s(<])) + \s*([_$a-zA-Z][$\w]*)? + captures: + 1: string.quoted.js + 2: punctuation.definition.string.begin.js + 3: entity.name.function.js + 4: punctuation.definition.string.end.js + 5: string.quoted.js + 6: punctuation.definition.string.begin.js + 7: entity.name.function.js + 8: punctuation.definition.string.end.js + 9: string.unquoted.js + 10: entity.name.function.js + 11: punctuation.separator.key-value.js + 12: storage.type.js + 13: storage.type.function.js + 14: keyword.generator.asterisk.js + 15: entity.name.function.js + push: + - meta_scope: meta.function.json.js + - match: (?<=\)) + pop: true + - include: flowtype-polymorph + - include: function-declaration-parameters + literal-jsx: + - match: '(?<=\(|\{|\[|,|&&|\|\||\?|:|=|=>|\Wreturn|^return|\Wdefault|^)(?=\s*<[_$a-zA-Z])' + push: + - meta_content_scope: meta.jsx.js + - match: (?<=/>|>) + pop: true + - include: jsx-tag-start + literal-keyword-storage: + - match: (?const|let|var)\b + scope: storage.type.js + literal-keywords: + - include: literal-keyword-storage + - match: (?await|yield))\b(?:\s*(\*))? + captures: + 1: keyword.control.flow.js + 2: keyword.generator.asterisk.js + - match: (?if|else)\b + scope: keyword.control.conditional.js + - match: (?catch|finally|throw|try)\b + scope: keyword.control.trycatch.js + - match: (?break|continue|do|goto|while|case|default)\b + scope: keyword.control.loop.js + - match: (?enum|module|public|package|private|interface|protected)\b + scope: keyword.other.reserved.js + - match: (? + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + )\s*:) + push: + - match: ":" + captures: + 0: punctuation.separator.key-value.js + pop: true + - include: literal-string + - match: '(? + ((')((?>[^'\\]|\\.)*)('))| + ((")((?>[^"\\]|\\.)*)("))| + (([_$a-zA-Z][$\w]*|\d+)) + ) + (?=\s*(\((?>(?>[^()]+)|\g<-1>)*\))(?>\s|/\*.*\*/)*\{) + captures: + 1: storage.type.js + 2: storage.type.js + 3: keyword.generator.asterisk.js + 4: string.quoted.js + 5: punctuation.definition.string.begin.js + 6: entity.name.function.js + 7: punctuation.definition.string.end.js + 8: string.quoted.js + 9: punctuation.definition.string.begin.js + 10: entity.name.function.js + 11: punctuation.definition.string.end.js + 12: string.unquoted.js + 13: entity.name.function.js + push: + - meta_scope: meta.method.js + - match: (?<=\)) + pop: true + - include: function-declaration-parameters + - match: |- + (?x) + \b(?:(static)\s+)? + (get|set)\s+ + ([_$a-zA-Z][$\w]*|\d+)\s* + (?=(\((?>(?>[^()]+)|\g<-1>)*\))(?>\s|/\*.*\*/)*\{) + captures: + 1: storage.type.js + 2: storage.type.accessor.js + 3: entity.name.accessor.js + push: + - meta_scope: meta.accessor.js + - match: (?<=\)) + pop: true + - include: function-declaration-parameters + literal-method-call: + - match: |- + (?x) + (?:(?<=\.)|\b) + ([A-Z][$\w]*)\s*(\.) + ([_$a-zA-Z][$\w]*)\s* + (\(\s*\)) + scope: meta.function-call.static.without-arguments.js + captures: + 1: variable.other.class.js + 2: keyword.operator.accessor.js + 3: variable.function.js + 4: meta.group.braces.round.function.arguments.js + - match: |- + (?x) + (?:(?<=\.)|\b) + ([A-Z][$\w]*)\s*(\.) + ([_$a-zA-Z][$\w]*)\s* + (?=\() + scope: meta.function-call.static.with-arguments.js + captures: + 1: variable.other.class.js + 2: keyword.operator.accessor.js + 3: variable.function.js + - match: |- + (?x) + (?<=\.) + ([_$a-zA-Z][$\w]*)\s* + (\(\s*\)) + scope: meta.function-call.method.without-arguments.js + captures: + 1: variable.function.js + 2: meta.group.braces.round.function.arguments.js + - match: |- + (?x) + (?<=\.) + ([_$a-zA-Z][$\w]*)\s* + (?=\() + scope: meta.function-call.method.with-arguments.js + captures: + 1: variable.function.js + literal-module: + - match: (?import|export|default|from|as)\b + scope: keyword.operator.module.js + literal-number: + - match: '(?i)(?:\B[-+]|\b)0x[0-9a-f]*\.(\B|\b[0-9]+)' + scope: invalid.illegal.numeric.hex.js + - match: '(?:\B[-+]|\b)0[0-9]+\.(\B|\b[0-9]+)' + scope: invalid.illegal.numeric.octal.js + - match: |- + (?xi) + (?:\B[-+])? + (?: + \b0b[0-1]*| # binary + \b0o[0-7]*| # octal + \b0x[0-9a-f]*| # hex + ( + \B\.[0-9]+| # e.g. .999 + \b[0-9]+(\.[0-9]*)? # e.g. 999.999, 999. or 999 + )(e[-+]?[0-9]+)? # e.g. e+123, E-123 + ) + scope: constant.numeric.js + - match: '(?:\B[-+]|\b)(Infinity)\b' + scope: constant.language.infinity.js + literal-operators: + - match: (?delete|instanceof|in|new|of|typeof|void|with)\b + scope: keyword.operator.js + - match: |- + (?x) + !(?!=)| # logical-not right-to-left right + && | # logical-and left-to-right both + \|\| # logical-or left-to-right both + scope: keyword.operator.logical.js + - match: |- + (?x) + =(?!=) # assignment right-to-left both + scope: keyword.operator.assignment.js + - match: |- + (?x) + %= | # assignment right-to-left both + &= | # assignment right-to-left both + \*= | # assignment right-to-left both + \+= | # assignment right-to-left both + -= | # assignment right-to-left both + /= | # assignment right-to-left both + \^= | # assignment right-to-left both + \|= | # assignment right-to-left both + <<= | # assignment right-to-left both + >>= | # assignment right-to-left both + >>>= # assignment right-to-left both + scope: keyword.operator.assignment.augmented.js + - match: |- + (?x) + ~ | # bitwise-not right-to-left right + << | # bitwise-shift left-to-right both + >>> | # bitwise-shift left-to-right both + >> | # bitwise-shift left-to-right both + & | # bitwise-and left-to-right both + \^ | # bitwise-xor left-to-right both + \| # bitwise-or left-to-right both + scope: keyword.operator.bitwise.js + - match: |- + (?x) + <= | # relational left-to-right both + >= | # relational left-to-right both + < | # relational left-to-right both + > # relational left-to-right both + scope: keyword.operator.relational.js + - match: |- + (?x) + === | # equality left-to-right both + !== | # equality left-to-right both + == | # equality left-to-right both + != # equality left-to-right both + scope: keyword.operator.comparison.js + - match: |- + (?x) + -- | # decrement n/a right-or-left + \+\+ | # increment n/a right-or-left + / | # division left-to-right both + % | # modulus left-to-right both + \* | # multiplication left-to-right both + \+ | # addition left-to-right both + - # subtraction left-to-right both + scope: keyword.operator.arithmetic.js + - match: "[?:]" + scope: keyword.operator.ternary.js + - match: (?|<=|>=|==|!=|===|!==|\+|-|\*|%|\+\+|--|<<|>>|>>>|&|\||\^|!|~|&&|\|\||\?|:|=|\+=|-=|\*=|%=|<<=|>>=|>>>=|&=|\|=|\^=|/|/=| + \Wnew|\Wdelete|\Wvoid|\Wtypeof|\Winstanceof|\Win|\Wdo|\Wreturn|\Wcase|\Wthrow|\Wyield| + ^new|^delete|^void|^typeof|^instanceof|^in|^do|^return|^case|^throw|^yield|^ + )\s* + (/) + (?!/|\*|$) + captures: + 1: punctuation.definition.string.begin.js + push: + - meta_scope: string.regexp.js + - match: "(/)([gimy]*)" + captures: + 1: punctuation.definition.string.end.js + 2: keyword.other.js + pop: true + - include: scope:source.regexp.js + literal-string: + - match: '(["''])' + captures: + 0: punctuation.definition.string.begin.js + push: + - meta_scope: string.quoted.js + - match: (\1)|(\n) + captures: + 1: punctuation.definition.string.end.js + 2: invalid.illegal.newline.js + pop: true + - include: string-content + literal-switch: + - match: (?]{7})\s(.+)$' + captures: + 1: invalid.illegal.conflict-marker.other-commit.js + 2: invalid.illegal.string.js + round-brackets: + - match: \( + captures: + 0: meta.brace.round.begin.js + push: + - meta_scope: meta.group.braces.round.js + - match: \) + captures: + 0: meta.brace.round.end.js + pop: true + - include: expression + square-brackets: + - match: '\[' + captures: + 0: meta.brace.square.begin.js + push: + - meta_scope: meta.group.braces.square.js + - match: '\]' + captures: + 0: meta.brace.square.end.js + pop: true + - include: expression + string-content: + - match: \\\s*\n + scope: constant.character.escape.newline.js + - match: '\\([1-7][0-7]{0,2}|[0-7]{2,3}|[bfnrtv0''"\\]|x\h{2}|u\{\h+\}|u\h{4})' + scope: constant.character.escape.js + styled-components: + - match: (?(?>[^()]+)|\g<-1>)*\))\s*`)' + captures: + 1: meta.function-call.with-arguments.js variable.function.js + push: + - meta_scope: meta.styled-components.js + - match: (?<=`) + captures: + 1: meta.function-call.with-arguments.js variable.function.js + pop: true + - match: \( + captures: + 0: punctuation.definition.group.begin.js + push: + - meta_scope: meta.function-call.with-arguments.js meta.group.js + - match: \) + captures: + 0: punctuation.definition.group.end.js + pop: true + - include: expression + - match: "`" + captures: + 0: punctuation.definition.string.template.begin.js + push: + - meta_content_scope: source.css.embedded.js + - match: "`" + captures: + 0: punctuation.definition.string.template.end.js + pop: true + - include: scope:source.js.css + support-class: + - match: (?Eval|Range|Reference|Syntax|Type|URI)?Error)\b + scope: support.class.error.js + - match: \b(?>Buffer)\b + scope: support.class.node.js + support-other: + - match: (?document|window)\b + scope: support.type.object.dom.js + - match: (?global|GLOBAL|root|__dirname|__filename)\b + scope: support.type.object.node.js + - match: (? Date: Tue, 14 May 2019 20:55:14 -0700 Subject: [PATCH 4/5] Remove tmLanguage files -Having used them to generate .sublime-syntax files, the .tmLanguage files can be removed. --- Packages/JSX/JavaScript (Babel).tmLanguage | 4003 -------------------- Packages/JSX/Styled Components.tmLanguage | 542 --- 2 files changed, 4545 deletions(-) delete mode 100644 Packages/JSX/JavaScript (Babel).tmLanguage delete mode 100644 Packages/JSX/Styled Components.tmLanguage diff --git a/Packages/JSX/JavaScript (Babel).tmLanguage b/Packages/JSX/JavaScript (Babel).tmLanguage deleted file mode 100644 index d1f580b..0000000 --- a/Packages/JSX/JavaScript (Babel).tmLanguage +++ /dev/null @@ -1,4003 +0,0 @@ - - - - - fileTypes - - js - jsx - babel - es6 - - firstLineMatch - ^#!\s*/.*\b(node|js)$\n? - name - JavaScript (Babel) - patterns - - - include - #core - - - repository - - brackets - - patterns - - - include - #round-brackets - - - include - #square-brackets - - - include - #curly-brackets - - - - class-method-definition - - patterns - - - begin - (@@[_$a-zA-Z][$\w]*|static|return)(?=\s*[<(])|(?=\s*<) - beginCaptures - - 1 - - name - keyword.operator.flowtype.js - - - end - (?=\s*[;{]) - name - meta.short-method.flowtype.js - patterns - - - include - #flowtype-polymorph - - - include - #function-declaration-parameters - - - include - #flowtype-annotation - - - include - #comments - - - include - #curly-brackets - - - - - begin - (?<=[]"'])\s*(?=[<(]) - end - (?=\s*[;{]) - name - meta.class-method.computed.js - patterns - - - include - #flowtype-polymorph - - - include - #function-declaration-parameters - - - include - #flowtype-annotation - - - include - #comments - - - include - #curly-brackets - - - - - begin - (?x) - ((?>get|set)\s+) - (?> - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - (([_$a-zA-Z][$\w]*|\d+)) - )(?=\s*[<(]) - beginCaptures - - 1 - - name - storage.type.js - - 10 - - name - string.unquoted.js - - 11 - - name - entity.name.function.js - - 2 - - name - string.quoted.js - - 3 - - name - punctuation.definition.string.begin.js - - 4 - - name - entity.name.function.js - - 5 - - name - punctuation.definition.string.end.js - - 6 - - name - string.quoted.js - - 7 - - name - punctuation.definition.string.begin.js - - 8 - - name - entity.name.function.js - - 9 - - name - punctuation.definition.string.end.js - - - end - (?=\s*[;{]) - name - meta.class-accessor.js - patterns - - - include - #flowtype-polymorph - - - include - #function-declaration-parameters - - - include - #flowtype-annotation - - - include - #comments - - - include - #curly-brackets - - - - - begin - (?x) - (?> - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - (([_$a-zA-Z][$\w]*|\d+)) - )(?=\s*[<(]) - beginCaptures - - 1 - - name - string.quoted.js - - 10 - - name - entity.name.function.js - - 2 - - name - punctuation.definition.string.begin.js - - 3 - - name - entity.name.function.js - - 4 - - name - punctuation.definition.string.end.js - - 5 - - name - string.quoted.js - - 6 - - name - punctuation.definition.string.begin.js - - 7 - - name - entity.name.function.js - - 8 - - name - punctuation.definition.string.end.js - - 9 - - name - string.unquoted.js - - - end - (?=\s*[;{]) - name - meta.class-method.js - patterns - - - include - #flowtype-polymorph - - - include - #function-declaration-parameters - - - include - #flowtype-annotation - - - include - #comments - - - include - #curly-brackets - - - - - - class-method-storage - - patterns - - - match - (?<!\.)\b(?>static|declare)\b - name - storage.modifier.js - - - match - (?<!\.)\b(async)\b - name - storage.type.js - - - match - (?<!\.)\b(get|set)\b(?!\s*\() - name - storage.type.js - - - match - \* - name - keyword.generator.asterisk.js - - - - class-properties - - patterns - - - begin - ([_$a-zA-Z][$\w]*)(?=\s*[:=]) - beginCaptures - - 1 - - name - variable.other.property.js - - - end - (?=\s*[;}]) - name - meta.class.property.js - patterns - - - include - #flowtype-annotation - - - include - #expression - - - - - - comments - - patterns - - - begin - /\*\*(?!/) - captures - - 0 - - name - punctuation.definition.comment.js - - - end - \*/ - name - comment.block.documentation.js - - - begin - /\* - beginCaptures - - 0 - - name - punctuation.definition.comment.begin.js - - - end - \*/ - endCaptures - - 0 - - name - punctuation.definition.comment.end.js - - - name - comment.block.js - - - captures - - 0 - - name - punctuation.definition.comment.js - - - match - (?><!--|-->) - name - comment.block.html.js - - - captures - - 1 - - name - punctuation.definition.comment.js - - - match - (//).*$\n? - name - comment.line.double-slash.js - - - captures - - 1 - - name - punctuation.definition.comment.js - - - match - ^(#!).*$\n? - name - comment.line.shebang.js - - - - core - - patterns - - - include - #literal-function-labels - - - include - #literal-arrow-function-labels - - - include - #literal-labels - - - include - #literal-for - - - include - #literal-switch - - - include - #styled-components - - - include - #graphql - - - include - #expression - - - include - #literal-punctuation - - - - curly-brackets - - patterns - - - begin - { - beginCaptures - - 0 - - name - meta.brace.curly.begin.js - - - end - } - endCaptures - - 0 - - name - meta.brace.curly.end.js - - - name - meta.group.braces.curly.js - patterns - - - include - $self - - - - - - es7-decorators - - patterns - - - captures - - 1 - - name - punctuation.definition.tag.js - - 2 - - name - entity.name.tag.js - - - match - (?x) - (@)([_$a-zA-Z][$\w]*)\b - name - tag.decorator.js - - - - expression - - patterns - - - include - #merge-conflits - - - include - #literal-regexp - - - include - #literal-jsx - - - include - #es7-decorators - - - include - #support-class - - - include - #support-other - - - include - #literal-function - - - include - #literal-arrow-function - - - include - #literal-prototype - - - include - #literal-keywords - - - include - #literal-method - - - include - #literal-module - - - include - #literal-class - - - include - #flowtype-declaration - - - include - #literal-number - - - include - #literal-template-string - - - include - #literal-string - - - include - #literal-language-constant - - - include - #literal-language-variable - - - include - #literal-constructor - - - include - #literal-method-call - - - include - #literal-function-call - - - include - #comments - - - include - #brackets - - - include - #literal-operators - - - include - #literal-variable - - - - flowtype-annotation - - patterns - - - applyEndPatternLast - 1 - begin - (?:(\?)\s*)?(:) - beginCaptures - - 1 - - name - keyword.operator.flowtype.optional.js - - 2 - - name - keyword.operator.flowtype.annotation.js - - - end - (?=\S) - name - meta.flowtype.annotation.js - patterns - - - include - #flowtype-tokens - - - - - - flowtype-brackets - - patterns - - - begin - { - beginCaptures - - 0 - - name - punctuation.section.flowtype.begin.js - - - end - } - endCaptures - - 0 - - name - punctuation.section.flowtype.end.js - - - patterns - - - include - #flowtype-tokens - - - - - - flowtype-declaration - - patterns - - - match - (?<!\.)\b(declare)\b - name - support.type.declare.flowtype.js - - - begin - (?<!\.)\b(type)\b(?=\s*[_$a-zA-Z]) - beginCaptures - - 1 - - name - support.type.type.flowtype.js - - - end - (?=\s*(;|from)) - name - meta.type.flowtype.js - patterns - - - include - #flowtype-tokens - - - - - begin - (?<!\.)\b(type)\b(?=\s*{) - beginCaptures - - 1 - - name - support.type.type.flowtype.js - - - end - (?<=}) - name - meta.type.flowtype.js - patterns - - - include - #comments - - - include - #flowtype-brackets - - - include - #flowtype-polymorph - - - match - ([_$a-zA-Z][$\w]*) - name - entity.name.type.js - - - - - - flowtype-identifier - - patterns - - - include - #support-class - - - match - \b(?:any|bool|boolean|mixed|number|string|void)\b - name - constant.other.primitve.flowtype.js - - - match - [_$a-zA-Z][$\w]* - name - variable.other.flowtype.js - - - match - \? - name - keyword.operator.flowtype.optional.js - - - - flowtype-polymorph - - begin - < - beginCaptures - - 0 - - name - punctuation.section.flowtype.begin.js - - - end - > - endCaptures - - 0 - - name - punctuation.section.flowtype.end.js - - - name - meta.flowtype.polymorph.js - patterns - - - include - #flowtype-tokens - - - - flowtype-tokens - - patterns - - - begin - (?<=[:?|&=])(?=\s*{) - end - (?<=}) - patterns - - - include - #flowtype-brackets - - - - - captures - - 1 - - name - keyword.operator.flowtype.other.js - - - match - \s*([|&])\s* - name - meta.flowtype.set.js - - - match - [*:?&|.]|\.\.\.|\b(typeof)\b - name - keyword.operator.flowtype.other.js - - - begin - < - beginCaptures - - 0 - - name - punctuation.section.flowtype.begin.js - - - end - > - endCaptures - - 0 - - name - punctuation.section.flowtype.end.js - - - patterns - - - include - #flowtype-tokens - - - - - begin - \[ - beginCaptures - - 0 - - name - punctuation.section.flowtype.begin.js - - - end - \] - endCaptures - - 0 - - name - punctuation.section.flowtype.end.js - - - patterns - - - include - #flowtype-tokens - - - - - begin - \( - beginCaptures - - 0 - - name - punctuation.section.flowtype.begin.js - - - end - \) - endCaptures - - 0 - - name - punctuation.section.flowtype.end.js - - - patterns - - - include - #flowtype-tokens - - - - - begin - => - beginCaptures - - 0 - - name - keyword.operator.flowtype.js - - - end - (?<=}|[_$a-zA-Z]) - name - meta.flowtype.function.js - patterns - - - include - #flowtype-brackets - - - include - #flowtype-identifier - - - include - #comments - - - - - include - #flowtype-identifier - - - include - #literal-string - - - include - #comments - - - - function-declaration-parameters - - patterns - - - begin - \( - beginCaptures - - 0 - - name - punctuation.definition.parameters.begin.js - - - end - \) - endCaptures - - 0 - - name - punctuation.definition.parameters.end.js - - - patterns - - - include - #comments - - - include - #flowtype-annotation - - - match - (?<!\.)\.\.\. - name - keyword.operator.spread.js - - - match - ([_$a-zA-Z][$\w]*) - name - variable.parameter.function.js - - - match - , - name - punctuation.separator.parameter.function.js - - - begin - = - beginCaptures - - 0 - - name - keyword.operator.assignment.js - - - end - (?=[,)]) - name - meta.parameter.optional.js - patterns - - - include - #expression - - - - - - - - graphql - - patterns - - - begin - \s*+gql` - end - ` - name - meta.graphql.js - patterns - - - include - source.graphql - - - begin - \${ - end - } - name - js - patterns - - - include - #core - - - - - - - begin - \s*+`#graphql - end - ` - name - meta.graphql.js - patterns - - - include - source.graphql - - - begin - \${ - end - } - name - js - patterns - - - include - #core - - - - - - - - jsx-attribute-assignment - - match - = - name - keyword.operator.assignment.jsx - - jsx-attribute-name - - match - [_$a-zA-Z][-$\w]* - name - entity.other.attribute-name.jsx - - jsx-attributes - - patterns - - - include - #jsx-attribute-name - - - include - #jsx-attribute-assignment - - - include - #jsx-string-quoted - - - include - #jsx-evaluated-code - - - include - #comments - - - - jsx-entities - - patterns - - - match - &(?:[a-zA-Z0-9]+|#\d+|#x\h+); - name - constant.character.entity.jsx - - - match - &\S*; - name - invalid.illegal.bad-ampersand.jsx - - - - jsx-evaluated-code - - begin - { - beginCaptures - - 0 - - name - punctuation.section.embedded.begin.jsx - - - end - } - endCaptures - - 0 - - name - punctuation.section.embedded.end.jsx - - - name - meta.embedded.expression.jsx - patterns - - - include - #expression - - - - jsx-string-quoted - - begin - (["']) - beginCaptures - - 0 - - name - punctuation.definition.string.begin.jsx - - - end - \1 - endCaptures - - 0 - - name - punctuation.definition.string.end.jsx - - - name - string.quoted.jsx - patterns - - - include - #jsx-entities - - - - jsx-tag-end - - begin - > - beginCaptures - - 0 - - name - meta.tag.jsx punctuation.definition.tag.end.jsx - - - end - (?=</) - patterns - - - include - #jsx-tag-start - - - include - #jsx-evaluated-code - - - include - #jsx-entities - - - - jsx-tag-start - - patterns - - - begin - (<)([_$a-zA-Z][-$:.\w]*[$\w]*) - beginCaptures - - 1 - - name - meta.tag.jsx punctuation.definition.tag.begin.jsx - - 2 - - name - meta.tag.jsx entity.name.tag.jsx - - - end - (</)(\2)(>)|(/>) - endCaptures - - 1 - - name - meta.tag.jsx punctuation.definition.tag.begin.jsx - - 2 - - name - meta.tag.jsx entity.name.tag.jsx - - 3 - - name - meta.tag.jsx punctuation.definition.tag.end.jsx - - 4 - - name - meta.tag.jsx punctuation.definition.tag.end.jsx - - - patterns - - - include - #jsx-tag-end - - - include - #jsx-attributes - - - - - match - < - name - invalid.illegal.tag.incomplete.jsx - - - - literal-arrow-function - - patterns - - - begin - (?x) - (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? - (?:\b(async)\s+)? - (?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) - beginCaptures - - 1 - - name - entity.name.function.js - - 2 - - name - keyword.operator.assignment.js - - 3 - - name - storage.type.js - - - end - (?<=\))\s*(=>) - endCaptures - - 1 - - name - storage.type.function.arrow.js - - - name - meta.function.arrow.js - patterns - - - include - #function-declaration-parameters - - - - - captures - - 1 - - name - entity.name.function.js - - 2 - - name - keyword.operator.assignment.js - - 3 - - name - storage.type.js - - 4 - - name - variable.parameter.function.js - - 5 - - name - storage.type.function.arrow.js - - - match - (?x) - (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? - (?:(async)\s+)? - \b([_$a-zA-Z][$\w]*)\s*(=>) - name - meta.function.arrow.js - - - begin - (?x) - (\b_?[A-Z][$\w]*)? - (\.)(prototype) - (\.)([_$a-zA-Z][$\w]*) - \s*(=) - \s*(async)? - \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) - beginCaptures - - 1 - - name - entity.name.class.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - variable.language.prototype.js - - 4 - - name - keyword.operator.accessor.js - - 5 - - name - entity.name.function.js - - 6 - - name - keyword.operator.assignment.js - - 7 - - name - storage.type.js - - - end - (?<=\))\s*(=>) - endCaptures - - 1 - - name - storage.type.function.arrow.js - - - name - meta.prototype.function.arrow.js - patterns - - - include - #function-declaration-parameters - - - - - captures - - 1 - - name - entity.name.class.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - variable.language.prototype.js - - 4 - - name - keyword.operator.accessor.js - - 5 - - name - entity.name.function.js - - 6 - - name - keyword.operator.assignment.js - - 7 - - name - storage.type.js - - 8 - - name - variable.parameter.function.js - - 9 - - name - storage.type.function.arrow.js - - - match - (?x) - (\b_?[A-Z][$\w]*)? - (\.)(prototype) - (\.)([_$a-zA-Z][$\w]*) - \s*(=) - \s*(async)? - \s*\b([_$a-zA-Z][$\w]*)\s*(=>) - name - meta.prototype.function.arrow.js - - - begin - (?x) - (\b_?[A-Z][$\w]*)? - (\.)([_$a-zA-Z][$\w]*) - \s*(=) - \s*(async)? - \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) - beginCaptures - - 1 - - name - entity.name.class.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - entity.name.function.js - - 4 - - name - keyword.operator.assignment.js - - 5 - - name - storage.type.js - - - end - (?<=\))\s*(=>) - endCaptures - - 1 - - name - storage.type.function.arrow.js - - - name - meta.function.static.arrow.js - patterns - - - include - #function-declaration-parameters - - - - - captures - - 1 - - name - entity.name.class.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - entity.name.function.js - - 4 - - name - keyword.operator.assignment.js - - 5 - - name - storage.type.js - - 6 - - name - variable.parameter.function.js - - 7 - - name - storage.type.function.arrow.js - - - match - (?x) - (\b_?[A-Z][$\w]*)? - (\.)([_$a-zA-Z][$\w]*) - \s*(=) - \s*(async)? - \s*\b([_$a-zA-Z][$\w]*)\s*(=>) - name - meta.function.static.arrow.js - - - - literal-arrow-function-labels - - patterns - - - begin - (?x) - (?> - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - (([_$a-zA-Z][$\w]*|\d+)) - ) - \s*(:) - \s*(?:\b(async)\s+)? - \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) - beginCaptures - - 1 - - name - string.quoted.js - - 10 - - name - entity.name.function.js - - 11 - - name - punctuation.separator.key-value.js - - 12 - - name - storage.type.js - - 2 - - name - punctuation.definition.string.begin.js - - 3 - - name - entity.name.function.js - - 4 - - name - punctuation.definition.string.end.js - - 5 - - name - string.quoted.js - - 6 - - name - punctuation.definition.string.begin.js - - 7 - - name - entity.name.function.js - - 8 - - name - punctuation.definition.string.end.js - - 9 - - name - string.unquoted.js - - - end - (?<=\))\s*(=>) - endCaptures - - 1 - - name - storage.type.function.arrow.js - - - name - meta.function.json.arrow.js - patterns - - - include - #function-declaration-parameters - - - - - captures - - 1 - - name - string.quoted.js - - 10 - - name - entity.name.function.js - - 11 - - name - punctuation.separator.key-value.js - - 12 - - name - storage.type.js - - 13 - - name - variable.parameter.function.js - - 14 - - name - storage.type.function.arrow.js - - 2 - - name - punctuation.definition.string.begin.js - - 3 - - name - entity.name.function.js - - 4 - - name - punctuation.definition.string.end.js - - 5 - - name - string.quoted.js - - 6 - - name - punctuation.definition.string.begin.js - - 7 - - name - entity.name.function.js - - 8 - - name - punctuation.definition.string.end.js - - 9 - - name - string.unquoted.js - - - match - (?x) - (?> - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - (([_$a-zA-Z][$\w]*|\d+)) - ) - \s*(:) - \s*(?:\b(async)\s+)? - \s*\b([_$a-zA-Z][$\w]*)\s*(=>) - name - meta.function.json.arrow.js - - - - literal-class - - patterns - - - begin - (?<!\.)\b(?:(class)|(interface))\b - beginCaptures - - 1 - - name - storage.type.class.js - - 2 - - name - storage.type.interface.flowtype.js - - - end - \} - endCaptures - - 0 - - name - meta.brace.curly.end.js - - - name - meta.class.js - patterns - - - include - #comments - - - begin - ([_$a-zA-Z][$\w]*) - beginCaptures - - 0 - - name - entity.name.class.js - - - end - (?={) - patterns - - - include - #comments - - - include - #flowtype-polymorph - - - begin - (?<!\.)\b(extends)\b - beginCaptures - - 0 - - name - storage.type.extends.js - - - end - (?={) - name - meta.class.extends.js - patterns - - - include - #flowtype-polymorph - - - include - #expression - - - - - - - begin - \{ - beginCaptures - - 0 - - name - meta.brace.curly.begin.js - - - end - (?=}) - patterns - - - include - #es7-decorators - - - include - #class-properties - - - include - #class-method-definition - - - include - #class-method-storage - - - include - #brackets - - - include - #comments - - - - - - - - literal-constructor - - patterns - - - begin - (new)\s+(?=[_$a-zA-Z][$\w.]*) - beginCaptures - - 1 - - name - keyword.operator.new.js - - - end - (?![_$a-zA-Z][$\w.]*) - name - meta.instance.constructor.js - patterns - - - include - #support-class - - - include - #support-other - - - captures - - 2 - - name - variable.function.constructor.js - - - match - ([_$a-zA-Z][$\w.]*\.)?([_$a-zA-Z][$\w]*) - - - - - - literal-for - - patterns - - - begin - (?<!\.)\b(for)\b - beginCaptures - - 1 - - name - keyword.control.loop.js - - - end - \) - endCaptures - - 0 - - name - meta.brace.round.end.js - - - name - meta.for.js - patterns - - - include - #comments - - - begin - \( - beginCaptures - - 0 - - name - meta.brace.round.begin.js - - - end - (?=\)) - patterns - - - include - #literal-keyword-storage - - - include - #expression - - - include - #literal-punctuation - - - - - - - - literal-function - - patterns - - - begin - (?x) - (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? - (?:(async)\s+)? - (function)(?>\s*(\*)|(?=[\s(<])) - \s*([_$a-zA-Z][$\w]*)? - beginCaptures - - 1 - - name - entity.name.function.js - - 2 - - name - keyword.operator.assignment.js - - 3 - - name - storage.type.js - - 4 - - name - storage.type.function.js - - 5 - - name - keyword.generator.asterisk.js - - 6 - - name - entity.name.function.js - - - end - (?<=\)) - name - meta.function.js - patterns - - - include - #flowtype-polymorph - - - include - #function-declaration-parameters - - - - - begin - (?x) - (\b_?[A-Z][$\w]*)? - (\.)(prototype) - (\.)([_$a-zA-Z][$\w]*) - \s*(=) - \s*(?:(async)\s+)? - \s*(function)(?>\s*(\*)|(?=[\s(<])) - \s*([_$a-zA-Z][$\w]*)?\s* - beginCaptures - - 1 - - name - entity.name.class.js - - 10 - - name - entity.name.function.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - variable.language.prototype.js - - 4 - - name - keyword.operator.accessor.js - - 5 - - name - entity.name.function.js - - 6 - - name - keyword.operator.assignment.js - - 7 - - name - storage.type.js - - 8 - - name - storage.type.function.js - - 9 - - name - keyword.generator.asterisk.js - - - end - (?<=\)) - name - meta.function.prototype.js - patterns - - - include - #flowtype-polymorph - - - include - #function-declaration-parameters - - - - - begin - (?x) - (\b_?[A-Z][$\w]*)? - (\.)([_$a-zA-Z][$\w]*) - \s*(=) - \s*(?:(async)\s+)? - \s*(function)(?>\s*(\*)|(?=[\s(<])) - \s*([_$a-zA-Z][$\w]*)?\s* - beginCaptures - - 1 - - name - entity.name.class.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - entity.name.function.js - - 4 - - name - keyword.operator.assignment.js - - 5 - - name - storage.type.js - - 6 - - name - storage.type.function.js - - 7 - - name - keyword.generator.asterisk.js - - 8 - - name - entity.name.function.js - - - end - (?<=\)) - name - meta.function.static.js - patterns - - - include - #flowtype-polymorph - - - include - #function-declaration-parameters - - - - - - literal-function-call - - patterns - - - captures - - 1 - - name - variable.function.js - - 2 - - name - meta.group.braces.round.function.arguments.js - - - match - ([_$a-zA-Z][$\w]*)\s*(\(\s*\)) - name - meta.function-call.without-arguments.js - - - captures - - 1 - - name - variable.function.js - - - match - ([_$a-zA-Z][$\w]*)\s*(?=\() - name - meta.function-call.with-arguments.js - - - captures - - 1 - - name - variable.function.js - - - match - ([_$a-zA-Z][$\w]*)\s*(?=`) - name - meta.function-call.tagged-template.js - - - - literal-function-labels - - patterns - - - begin - (?x) - (?> - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - (([_$a-zA-Z][$\w]*|\d+)) - ) - \s*(:) - \s*(?:\b(async)\s+)? - \s*(function)(?>\s*(\*)|(?=[\s(<])) - \s*([_$a-zA-Z][$\w]*)? - beginCaptures - - 1 - - name - string.quoted.js - - 10 - - name - entity.name.function.js - - 11 - - name - punctuation.separator.key-value.js - - 12 - - name - storage.type.js - - 13 - - name - storage.type.function.js - - 14 - - name - keyword.generator.asterisk.js - - 15 - - name - entity.name.function.js - - 2 - - name - punctuation.definition.string.begin.js - - 3 - - name - entity.name.function.js - - 4 - - name - punctuation.definition.string.end.js - - 5 - - name - string.quoted.js - - 6 - - name - punctuation.definition.string.begin.js - - 7 - - name - entity.name.function.js - - 8 - - name - punctuation.definition.string.end.js - - 9 - - name - string.unquoted.js - - - end - (?<=\)) - name - meta.function.json.js - patterns - - - include - #flowtype-polymorph - - - include - #function-declaration-parameters - - - - - - literal-jsx - - begin - (?<=\(|\{|\[|,|&&|\|\||\?|:|=|=>|\Wreturn|^return|\Wdefault|^)(?=\s*<[_$a-zA-Z]) - contentName - meta.jsx.js - end - (?<=/>|>) - patterns - - - include - #jsx-tag-start - - - - literal-keyword-storage - - patterns - - - match - (?<!\.)\b(?>const|let|var)\b - name - storage.type.js - - - - literal-keywords - - patterns - - - include - #literal-keyword-storage - - - captures - - 1 - - name - keyword.control.flow.js - - 2 - - name - keyword.generator.asterisk.js - - - match - (?<!\.)\b((?>await|yield))\b(?:\s*(\*))? - - - match - (?<!\.)\b(return)\b - name - keyword.control.flow.js - - - match - (?<!\.)\b(?>if|else)\b - name - keyword.control.conditional.js - - - match - (?<!\.)\b(?>catch|finally|throw|try)\b - name - keyword.control.trycatch.js - - - match - (?<!\.)\b(?>break|continue|do|goto|while|case|default)\b - name - keyword.control.loop.js - - - match - (?<!\.)\b(?>enum|module|public|package|private|interface|protected)\b - name - keyword.other.reserved.js - - - match - (?<!\.)\b(debugger)\b - name - keyword.other.js - - - - literal-labels - - patterns - - - begin - (?x) - (?<!\?)(?<!\?\s)(?=(?> - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - )\s*:) - end - : - endCaptures - - 0 - - name - punctuation.separator.key-value.js - - - patterns - - - include - #literal-string - - - - - captures - - 1 - - name - string.unquoted.label.js - - 2 - - name - punctuation.separator.key-value.js - - - match - (?<!\.|\?|\?\s)([_$a-zA-Z][$\w]*)\s*(:) - name - constant.other.object.key.js - - - - literal-language-constant - - patterns - - - match - (?<!\.)\b(true)\b - name - constant.language.boolean.true.js - - - match - (?<!\.)\b(false)\b - name - constant.language.boolean.false.js - - - match - (?<!\.)\b(null)\b - name - constant.language.null.js - - - match - (?<!\.)\b(undefined)\b - name - constant.language.undefined.js - - - match - (?<!\.)\b(NaN)\b - name - constant.language.nan.js - - - - literal-language-variable - - patterns - - - match - (?<!(?<!\.\.)\.)\b(arguments)\b - name - variable.language.arguments.js - - - match - (?<!(?<!\.\.)\.)\b(super)\b - name - variable.language.super.js - - - match - (?<!(?<!\.\.)\.)\b(this)\b - name - variable.language.this.js - - - match - (?<!(?<!\.\.)\.)\b(self)\b - name - variable.language.self.js - - - match - (?<=\.)(__proto__)\b - name - variable.language.proto.js - - - match - (?<=\.)(constructor)\b - name - variable.language.constructor.js - - - match - (?<=\.)(prototype)\b - name - variable.language.prototype.js - - - - literal-method - - patterns - - - begin - (?x) - (?:\b(static)\s+)? - (?:\b(async)\s+)? - (?:(\*)\s*)? - (?> - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - (([_$a-zA-Z][$\w]*|\d+)) - ) - (?=\s*(\((?>(?>[^()]+)|\g<-1>)*\))(?>\s|/\*.*\*/)*\{) - beginCaptures - - 1 - - name - storage.type.js - - 10 - - name - entity.name.function.js - - 11 - - name - punctuation.definition.string.end.js - - 12 - - name - string.unquoted.js - - 13 - - name - entity.name.function.js - - 2 - - name - storage.type.js - - 3 - - name - keyword.generator.asterisk.js - - 4 - - name - string.quoted.js - - 5 - - name - punctuation.definition.string.begin.js - - 6 - - name - entity.name.function.js - - 7 - - name - punctuation.definition.string.end.js - - 8 - - name - string.quoted.js - - 9 - - name - punctuation.definition.string.begin.js - - - end - (?<=\)) - name - meta.method.js - patterns - - - include - #function-declaration-parameters - - - - - begin - (?x) - \b(?:(static)\s+)? - (get|set)\s+ - ([_$a-zA-Z][$\w]*|\d+)\s* - (?=(\((?>(?>[^()]+)|\g<-1>)*\))(?>\s|/\*.*\*/)*\{) - beginCaptures - - 1 - - name - storage.type.js - - 2 - - name - storage.type.accessor.js - - 3 - - name - entity.name.accessor.js - - - end - (?<=\)) - name - meta.accessor.js - patterns - - - include - #function-declaration-parameters - - - - - - literal-method-call - - patterns - - - captures - - 1 - - name - variable.other.class.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - variable.function.js - - 4 - - name - meta.group.braces.round.function.arguments.js - - - match - (?x) - (?:(?<=\.)|\b) - ([A-Z][$\w]*)\s*(\.) - ([_$a-zA-Z][$\w]*)\s* - (\(\s*\)) - name - meta.function-call.static.without-arguments.js - - - captures - - 1 - - name - variable.other.class.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - variable.function.js - - - match - (?x) - (?:(?<=\.)|\b) - ([A-Z][$\w]*)\s*(\.) - ([_$a-zA-Z][$\w]*)\s* - (?=\() - name - meta.function-call.static.with-arguments.js - - - captures - - 1 - - name - variable.function.js - - 2 - - name - meta.group.braces.round.function.arguments.js - - - match - (?x) - (?<=\.) - ([_$a-zA-Z][$\w]*)\s* - (\(\s*\)) - name - meta.function-call.method.without-arguments.js - - - captures - - 1 - - name - variable.function.js - - - match - (?x) - (?<=\.) - ([_$a-zA-Z][$\w]*)\s* - (?=\() - name - meta.function-call.method.with-arguments.js - - - - literal-module - - patterns - - - match - (?<!\.)\b(?>import|export|default|from|as)\b - name - keyword.operator.module.js - - - - literal-number - - patterns - - - match - (?i)(?:\B[-+]|\b)0x[0-9a-f]*\.(\B|\b[0-9]+) - name - invalid.illegal.numeric.hex.js - - - match - (?:\B[-+]|\b)0[0-9]+\.(\B|\b[0-9]+) - name - invalid.illegal.numeric.octal.js - - - match - (?xi) - (?:\B[-+])? - (?: - \b0b[0-1]*| # binary - \b0o[0-7]*| # octal - \b0x[0-9a-f]*| # hex - ( - \B\.[0-9]+| # e.g. .999 - \b[0-9]+(\.[0-9]*)? # e.g. 999.999, 999. or 999 - )(e[-+]?[0-9]+)? # e.g. e+123, E-123 - ) - name - constant.numeric.js - - - match - (?:\B[-+]|\b)(Infinity)\b - name - constant.language.infinity.js - - - - literal-operators - - patterns - - - match - (?<!\.)\b(?>delete|instanceof|in|new|of|typeof|void|with)\b - name - keyword.operator.js - - - match - (?x) - !(?!=)| # logical-not right-to-left right - && | # logical-and left-to-right both - \|\| # logical-or left-to-right both - name - keyword.operator.logical.js - - - match - (?x) - =(?!=) # assignment right-to-left both - name - keyword.operator.assignment.js - - - match - (?x) - %= | # assignment right-to-left both - &= | # assignment right-to-left both - \*= | # assignment right-to-left both - \+= | # assignment right-to-left both - -= | # assignment right-to-left both - /= | # assignment right-to-left both - \^= | # assignment right-to-left both - \|= | # assignment right-to-left both - <<= | # assignment right-to-left both - >>= | # assignment right-to-left both - >>>= # assignment right-to-left both - name - keyword.operator.assignment.augmented.js - - - match - (?x) - ~ | # bitwise-not right-to-left right - << | # bitwise-shift left-to-right both - >>> | # bitwise-shift left-to-right both - >> | # bitwise-shift left-to-right both - & | # bitwise-and left-to-right both - \^ | # bitwise-xor left-to-right both - \| # bitwise-or left-to-right both - name - keyword.operator.bitwise.js - - - match - (?x) - <= | # relational left-to-right both - >= | # relational left-to-right both - < | # relational left-to-right both - > # relational left-to-right both - name - keyword.operator.relational.js - - - match - (?x) - === | # equality left-to-right both - !== | # equality left-to-right both - == | # equality left-to-right both - != # equality left-to-right both - name - keyword.operator.comparison.js - - - match - (?x) - -- | # decrement n/a right-or-left - \+\+ | # increment n/a right-or-left - / | # division left-to-right both - % | # modulus left-to-right both - \* | # multiplication left-to-right both - \+ | # addition left-to-right both - - # subtraction left-to-right both - name - keyword.operator.arithmetic.js - - - match - [?:] - name - keyword.operator.ternary.js - - - match - (?<!\.)\.\.\. - name - keyword.operator.spread.js - - - match - \. - name - keyword.operator.accessor.js - - - - literal-prototype - - patterns - - - captures - - 1 - - name - entity.name.class.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - variable.language.prototype.js - - 4 - - name - keyword.operator.assignment.js - - - match - ([_$a-zA-Z][$\w]*)(\.)(prototype)\s*(=)\s* - name - meta.prototype.declaration.js - - - captures - - 1 - - name - entity.name.class.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - variable.language.prototype.js - - - match - ([_$a-zA-Z][$\w]*)(\.)(prototype)\b - name - meta.prototype.access.js - - - - literal-punctuation - - patterns - - - match - ; - name - punctuation.terminator.statement.js - - - match - , - name - meta.delimiter.comma.js - - - - literal-regexp - - patterns - - - begin - (?x) - (?<= - \.|\(|,|{|}|\[|;|<|>|<=|>=|==|!=|===|!==|\+|-|\*|%|\+\+|--|<<|>>|>>>|&|\||\^|!|~|&&|\|\||\?|:|=|\+=|-=|\*=|%=|<<=|>>=|>>>=|&=|\|=|\^=|/|/=| - \Wnew|\Wdelete|\Wvoid|\Wtypeof|\Winstanceof|\Win|\Wdo|\Wreturn|\Wcase|\Wthrow|\Wyield| - ^new|^delete|^void|^typeof|^instanceof|^in|^do|^return|^case|^throw|^yield|^ - )\s* - (/) - (?!/|\*|$) - beginCaptures - - 1 - - name - punctuation.definition.string.begin.js - - - end - (/)([gimy]*) - endCaptures - - 1 - - name - punctuation.definition.string.end.js - - 2 - - name - keyword.other.js - - - name - string.regexp.js - patterns - - - include - source.regexp.js - - - - - - literal-string - - patterns - - - begin - (["']) - beginCaptures - - 0 - - name - punctuation.definition.string.begin.js - - - end - (\1)|(\n) - endCaptures - - 1 - - name - punctuation.definition.string.end.js - - 2 - - name - invalid.illegal.newline.js - - - name - string.quoted.js - patterns - - - include - #string-content - - - - - - literal-switch - - patterns - - - begin - (?<!\.)\b(switch)\b - beginCaptures - - 1 - - name - keyword.control.switch.js - - - end - \} - endCaptures - - 0 - - name - meta.brace.curly.end.js - - - name - meta.switch.js - patterns - - - include - #comments - - - include - #round-brackets - - - begin - \{ - beginCaptures - - 0 - - name - meta.brace.curly.begin.js - - - end - (?=}) - patterns - - - begin - (?<!\.)\b(case|default)\b - beginCaptures - - 1 - - name - keyword.control.switch.js - - - end - (?=:) - patterns - - - include - #expression - - - - - include - $self - - - - - - - - literal-template-string - - begin - ` - beginCaptures - - 0 - - name - string.interpolated.js keyword.other.template.begin.js - - - captures - - 0 - - name - string.interpolated.js keyword.other.template.end.js - - - end - ` - patterns - - - include - #string-content - - - match - \\` - name - constant.character.escape.js - - - begin - \${ - beginCaptures - - 0 - - name - keyword.other.substitution.begin.js - - - end - } - endCaptures - - 0 - - name - keyword.other.substitution.end.js - - - patterns - - - include - #expression - - - - - match - . - name - string.interpolated.js - - - - literal-variable - - patterns - - - match - _*?[A-Z][_$\dA-Z]*\b - name - variable.other.constant.js - - - captures - - 1 - - name - variable.other.class.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - variable.other.property.static.js - - - match - \b([A-Z][$\w]*)\s*(\.)([_$a-zA-Z][$\w]*) - name - meta.property.class.js - - - captures - - 1 - - name - variable.other.object.js - - - match - (?<!\.)([_$a-zA-Z][$\w]*)\s*(?=[\[\.]) - name - variable.other.object.js - - - captures - - 1 - - name - variable.other.property.js - - - match - (?<=\.)\s*([_$a-zA-Z][$\w]*) - name - meta.property.object.js - - - match - [_$a-zA-Z][$\w]* - name - variable.other.readwrite.js - - - - merge-conflits - - patterns - - - captures - - 1 - - name - invalid.illegal.conflict-marker.merge-into.js - - 2 - - name - invalid.illegal.string.js - - - match - ^([<]{7})\s(.+)$ - - - captures - - 1 - - name - invalid.illegal.conflict-marker.separator.js - - - match - ^([=|]{7})$ - - - captures - - 1 - - name - invalid.illegal.conflict-marker.other-commit.js - - 2 - - name - invalid.illegal.string.js - - - match - ^([>]{7})\s(.+)$ - - - - round-brackets - - patterns - - - begin - \( - beginCaptures - - 0 - - name - meta.brace.round.begin.js - - - end - \) - endCaptures - - 0 - - name - meta.brace.round.end.js - - - name - meta.group.braces.round.js - patterns - - - include - #expression - - - - - - square-brackets - - patterns - - - begin - \[ - beginCaptures - - 0 - - name - meta.brace.square.begin.js - - - end - \] - endCaptures - - 0 - - name - meta.brace.square.end.js - - - name - meta.group.braces.square.js - patterns - - - include - #expression - - - - - - string-content - - patterns - - - match - \\\s*\n - name - constant.character.escape.newline.js - - - match - \\([1-7][0-7]{0,2}|[0-7]{2,3}|[bfnrtv0'"\\]|x\h{2}|u\{\h+\}|u\h{4}) - name - constant.character.escape.js - - - - styled-components - - patterns - - - begin - (?<!\.)\b(injectGlobal|keyframes)\s*(`) - beginCaptures - - 1 - - name - variable.function.tagged-template.js - - 2 - - name - punctuation.definition.string.template.begin.js - - - contentName - source.css.embedded.js - end - ` - endCaptures - - 0 - - name - punctuation.definition.string.template.end.js - - - name - meta.styled-components.js - patterns - - - include - source.js.css - - - - - begin - (?<!\.)\b(styled)(\.)([_$a-zA-Z][$\w]*)\s*(`) - beginCaptures - - 1 - - name - variable.other.object.js - - 2 - - name - punctuation.accessor.js - - 3 - - name - variable.function.tagged-template.js - - 4 - - name - punctuation.definition.string.template.begin.js - - - contentName - source.css.embedded.js - end - ` - endCaptures - - 0 - - name - punctuation.definition.string.template.end.js - - - name - meta.styled-components.js - patterns - - - include - source.js.css - - - - - begin - (?<!\.)\b(styled)\s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*`) - captures - - 1 - - name - meta.function-call.with-arguments.js variable.function.js - - - end - (?<=`) - name - meta.styled-components.js - patterns - - - begin - \( - beginCaptures - - 0 - - name - punctuation.definition.group.begin.js - - - end - \) - endCaptures - - 0 - - name - punctuation.definition.group.end.js - - - name - meta.function-call.with-arguments.js meta.group.js - patterns - - - include - #expression - - - - - begin - ` - beginCaptures - - 0 - - name - punctuation.definition.string.template.begin.js - - - contentName - source.css.embedded.js - end - ` - endCaptures - - 0 - - name - punctuation.definition.string.template.end.js - - - patterns - - - include - source.js.css - - - - - - - - support-class - - patterns - - - match - (?<!\.)\b(Array|ArrayBuffer|Boolean|DataView|Date|Float32Array|Float64Array|Function|Infinity|Int16Array|Int32Array|Int8Array|JSON|Map|Math|NaN|Number|Object|Promise|Proxy|Reflect|RegExp|Set|String|Symbol|System|TypeError|Uint16Array|Uint32Array|Uint8Array|Uint8ClampedArray|WeakMap|WeakSet)\b - name - support.class.builtin.js - - - match - (?<!\.)\b((?>Eval|Range|Reference|Syntax|Type|URI)?Error)\b - name - support.class.error.js - - - match - \b(?>Buffer)\b - name - support.class.node.js - - - - support-other - - patterns - - - match - (?<!\.)\b(constructor|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval|hasOwnProperty|isFinite|isNaN|isPrototypeOf|parseFloat|parseInt|propertyIsEnumerable|toLocaleString|toString|unescape|valueOf)\b - name - support.function.builtin.js - - - match - (?<!\.)\b(clearImmediate|clearInterval|clearTimeout|require|setImmediate|setInterval|setTimeout)\b - name - support.function.node.js - - - match - (?<!\.)\b(?>document|window)\b - name - support.type.object.dom.js - - - match - (?<!\.)\b(?>global|GLOBAL|root|__dirname|__filename)\b - name - support.type.object.node.js - - - captures - - 1 - - name - support.type.object.console.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - support.function.console.js - - - match - (?<!\.)\b(console)(?:(\.)(assert|count|dir|error|group|groupCollapsed|groupEnd|info|log|profile|profileEnd|table|time|timeEnd|trace|warn))?\b - - - captures - - 1 - - name - support.type.object.process.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - support.type.object.process.js - - 4 - - name - support.function.process.js - - - match - (?<!\.)\b(process)(?:(\.)(?:(arch|argv|config|env|execArgv|execPath|exitCode|mainModule|pid|platform|stderr|stdin|stdout|title|version|versions)|(abort|chdir|cwd|exit|getgid|getgroups|getuid|hrtime|initgroups|kill|memoryUsage|nextTick|setgid|setgroups|setuid|umask|uptime)))?\b - - - captures - - 1 - - name - support.type.object.module.js - - 2 - - name - keyword.operator.accessor.js - - 3 - - name - support.type.object.module.js - - - match - (?<!\.)\b(exports|module)(?:(\.)(children|exports|filename|id|loaded|parent))?\b - - - begin - {{ - end - }} - name - meta.tag.mustache.js - - - - - scopeName - source.js - - diff --git a/Packages/JSX/Styled Components.tmLanguage b/Packages/JSX/Styled Components.tmLanguage deleted file mode 100644 index 0c704e1..0000000 --- a/Packages/JSX/Styled Components.tmLanguage +++ /dev/null @@ -1,542 +0,0 @@ - - - - - comment - - foldingStartMarker - /\*\*(?!\*)|\{\s*($|/\*(?!.*?\*/.*\S)) - foldingStopMarker - (?<!\*)\*\*/|^\s*\} - keyEquivalent - ^~C - name - Styled Components - patterns - - - include - #comment-block - - - include - #rule-list - - - repository - - color-values - - patterns - - - comment - http://www.w3.org/TR/CSS21/syndata.html#value-def-color - match - \b(aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow)\b - name - support.constant.color.w3c-standard-color-name.css - - - comment - These colours are mostly recognised but will not validate. ref: http://www.w3schools.com/css/css_colornames.asp - match - \b(aliceblue|antiquewhite|aquamarine|azure|beige|bisque|blanchedalmond|blueviolet|brown|burlywood|cadetblue|chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkgrey|darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|darksalmon|darkseagreen|darkslateblue|darkslategray|darkslategrey|darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dimgrey|dodgerblue|firebrick|floralwhite|forestgreen|gainsboro|ghostwhite|gold|goldenrod|greenyellow|grey|honeydew|hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|lightgoldenrodyellow|lightgray|lightgreen|lightgrey|lightpink|lightsalmon|lightseagreen|lightskyblue|lightslategray|lightslategrey|lightsteelblue|lightyellow|limegreen|linen|magenta|mediumaquamarine|mediumblue|mediumorchid|mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|moccasin|navajowhite|oldlace|olivedrab|orangered|orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|powderblue|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|seashell|sienna|skyblue|slateblue|slategray|slategrey|snow|springgreen|steelblue|tan|thistle|tomato|turquoise|violet|wheat|whitesmoke|yellowgreen)\b - name - invalid.deprecated.color.w3c-non-standard-color-name.css - - - begin - (hsla?|rgba?)\s*(\() - beginCaptures - - 1 - - name - support.function.misc.css - - 2 - - name - punctuation.section.function.css - - - end - (\)) - endCaptures - - 1 - - name - punctuation.section.function.css - - - patterns - - - match - (?x)\b - (0*((1?[0-9]{1,2})|(2([0-4][0-9]|5[0-5])))\s*,\s*){2} - (0*((1?[0-9]{1,2})|(2([0-4][0-9]|5[0-5])))\b) - (\s*,\s*((0?\.[0-9]+)|[0-1]))? - - name - constant.other.color.rgb-value.css - - - match - \b([0-9]{1,2}|100)\s*%,\s*([0-9]{1,2}|100)\s*%,\s*([0-9]{1,2}|100)\s*% - name - constant.other.color.rgb-percentage.css - - - include - #numeric-values - - - - - - comment-block - - begin - /\* - captures - - 0 - - name - punctuation.definition.comment.css - - - end - \*/ - name - comment.block.css - - media-query - - begin - (?i)\s*(only|not)?\s*(all|aural|braille|embossed|handheld|print|projection|screen|tty|tv)? - beginCaptures - - 1 - - name - keyword.operator.logic.media.css - - 2 - - name - support.constant.media.css - - - end - \s*(?:(,)|(?=[{;])) - endCaptures - - 1 - - name - punctuation.definition.arbitrary-repitition.css - - - patterns - - - begin - \s*(and)?\s*(\()\s* - beginCaptures - - 1 - - name - keyword.operator.logic.media.css - - - end - \) - patterns - - - begin - (?x) - ( - ((min|max)-)? - ( - ((device-)?(height|width|aspect-ratio))| - (color(-index)?)|monochrome|resolution - ) - )|grid|scan|orientation - \s*(?=[:)]) - beginCaptures - - 0 - - name - support.type.property-name.media.css - - - end - (:)|(?=\)) - endCaptures - - 1 - - name - punctuation.separator.key-value.css - - - - - match - \b(portrait|landscape|progressive|interlace) - name - support.constant.property-value.css - - - captures - - 1 - - name - constant.numeric.css - - 2 - - name - keyword.operator.arithmetic.css - - 3 - - name - constant.numeric.css - - - match - \s*(\d+)(/)(\d+) - - - include - #numeric-values - - - - - - media-query-list - - begin - \s*(?=[^{;]) - end - \s*(?=[{;]) - patterns - - - include - #media-query - - - - numeric-values - - patterns - - - captures - - 1 - - name - punctuation.definition.constant.css - - - match - (#)([0-9a-fA-F]{3}|[0-9a-fA-F]{6})\b - name - constant.other.color.rgb-value.css - - - captures - - 1 - - name - keyword.other.unit.css - - - match - (?x) - (?:-|\+)?(?:(?:[0-9]+(?:\.[0-9]+)?)|(?:\.[0-9]+)) - ((?:px|pt|ch|cm|mm|in|r?em|ex|pc|deg|g?rad|dpi|dpcm|s)\b|%)? - - name - constant.numeric.css - - - - property-values - - patterns - - - match - \b(absolute|all(-scroll)?|always|armenian|auto|avoid|baseline|below|bidi-override|block|bold|bolder|both|bottom|break-all|break-word|capitalize|center|char|circle|cjk-ideographic|col-resize|collapse|crosshair|dashed|decimal-leading-zero|decimal|default|disabled|disc|distribute-all-lines|distribute-letter|distribute-space|distribute|dotted|double|e-resize|ellipsis|fixed|geometricPrecision|georgian|groove|hand|hebrew|help|hidden|hiragana-iroha|hiragana|horizontal|ideograph-alpha|ideograph-numeric|ideograph-parenthesis|ideograph-space|inactive|inherit|inline-block|inline|inset|inside|inter-ideograph|inter-word|italic|justify|katakana-iroha|katakana|keep-all|left|lighter|line-edge|line-through|line|list-item|loose|lower-alpha|lower-greek|lower-latin|lower-roman|lowercase|lr-tb|ltr|medium|middle|move|n-resize|ne-resize|newspaper|no-drop|no-repeat|nw-resize|none|normal|not-allowed|nowrap|oblique|optimize(Legibility|Quality|Speed)|outset|outside|overline|pointer|pre(-(wrap|line))?|progress|relative|repeat-x|repeat-y|repeat|right|ridge|row-resize|rtl|s-resize|scroll|se-resize|separate|small-caps|solid|square|static|strict|sub|super|sw-resize|table-footer-group|table-header-group|tb-rl|text-bottom|text-top|text|thick|thin|top|transparent|underline|upper-alpha|upper-latin|upper-roman|uppercase|vertical(-(ideographic|text))?|visible(Painted|Fill|Stroke)?|w-resize|wait|whitespace|zero|smaller|larger|((xx?-)?(small|large))|painted|fill|stroke)\b - name - support.constant.property-value.css - - - match - (\b(?i:arial|century|comic|courier|garamond|georgia|helvetica|impact|lucida|symbol|system|tahoma|times|trebuchet|utopia|verdana|webdings|sans-serif|serif|monospace)\b) - name - support.constant.font-name.css - - - include - #numeric-values - - - include - #color-values - - - include - #string-double - - - include - #string-single - - - begin - (rect)\s*(\() - beginCaptures - - 1 - - name - support.function.misc.css - - 2 - - name - punctuation.section.function.css - - - end - (\)) - endCaptures - - 1 - - name - punctuation.section.function.css - - - patterns - - - include - #numeric-values - - - - - begin - (format|local|url|attr|counter|counters)\s*(\() - beginCaptures - - 1 - - name - support.function.misc.css - - 2 - - name - punctuation.section.function.css - - - end - (\)) - endCaptures - - 1 - - name - punctuation.section.function.css - - - patterns - - - include - #string-single - - - include - #string-double - - - match - [^'") \t]+ - name - variable.parameter.misc.css - - - - - match - \!\s*important - name - keyword.other.important.css - - - - rule-list - - begin - - beginCaptures - - 0 - - name - punctuation.section.property-list.css - - - end - (?=\s*) - name - meta.property-list.css - patterns - - - include - #comment-block - - - begin - (?<![-a-z])(?=[-a-z]) - end - $|(?![-a-z]) - name - meta.property-name.css - patterns - - - match - \b(azimuth|background-attachment|background-color|background-image|background-position|background-repeat|background|box-shadow|border-radius|border-bottom-color|border-bottom-style|border-bottom-width|border-bottom|border-collapse|border-color|border-left-color|border-left-style|border-left-width|border-left|border-right-color|border-right-style|border-right-width|border-right|border-spacing|border-style|border-top-color|border-top-style|border-top-width|border-top|border-width|border|bottom|caption-side|clear|clip|color|content|counter-increment|counter-reset|cue-after|cue-before|cue|cursor|direction|display|elevation|empty-cells|flex-basis|flex-direction|flex-flow|flex-grow|flex-shrink|flex-wrap|flex|float|font-family|font-size-adjust|font-size|font-stretch|font-style|font-variant|font-weight|font|height|image-rendering|left|letter-spacing|line-height|list-style-image|list-style-position|list-style-type|list-style|margin-bottom|margin-left|margin-right|margin-top|marker-offset|margin|marks|max-height|max-width|min-height|min-width|-moz-border-radius|opacity|orphans|outline-color|outline-style|outline-width|outline|overflow(-[xy])?|padding-bottom|padding-left|padding-right|padding-top|padding|page-break-after|page-break-before|page-break-inside|page|pause-after|pause-before|pause|pitch-range|pitch|play-during|pointer-events|position|quotes|resize|richness|right|size|speak-header|speak-numeral|speak-punctuation|speech-rate|speak|src|stress|table-layout|text-(align|decoration|indent|rendering|shadow|transform)|top|transition|unicode-bidi|vertical-align|visibility|voice-family|volume|white-space|widows|width|word-(spacing|wrap)|zoom|z-index)\b - name - support.type.property-name.css - - - - - begin - (?<!&|:)(:)\s* - beginCaptures - - 1 - - name - punctuation.separator.key-value.css - - - end - \s*(;|(?=\})) - endCaptures - - 1 - - name - punctuation.terminator.rule.css - - - name - meta.property-value.css - patterns - - - include - #property-values - - - - - - string-double - - begin - " - beginCaptures - - 0 - - name - punctuation.definition.string.begin.css - - - end - " - endCaptures - - 0 - - name - punctuation.definition.string.end.css - - - name - string.quoted.double.css - patterns - - - match - \\. - name - constant.character.escape.css - - - - string-single - - begin - ' - beginCaptures - - 0 - - name - punctuation.definition.string.begin.css - - - end - ' - endCaptures - - 0 - - name - punctuation.definition.string.end.css - - - name - string.quoted.single.css - patterns - - - match - \\. - name - constant.character.escape.css - - - - - scopeName - source.js.css - uuid - b64876fa-0739-4b2b-8e5b-e9e8b9f84514 - - From de6c880bcf3333504c6f31a763d8aeb092a3b283 Mon Sep 17 00:00:00 2001 From: Matthias Date: Thu, 16 May 2019 22:17:05 -0700 Subject: [PATCH 5/5] Remove *.YAML files These files were YAML translations of .tmLanguage files, but in a different syntax than .submlime-syntax. I think they were used for generating the .tmLanguage files. Regardless, they were not being used. --- Packages/JSX/JSX (Inner).YAML-tmPreferences | 9 - Packages/JSX/JSX (Outer).YAML-tmPreferences | 16 - .../JSX/JavaScript (Babel).YAML-tmLanguage | 1467 ----------------- 3 files changed, 1492 deletions(-) delete mode 100644 Packages/JSX/JSX (Inner).YAML-tmPreferences delete mode 100644 Packages/JSX/JSX (Outer).YAML-tmPreferences delete mode 100644 Packages/JSX/JavaScript (Babel).YAML-tmLanguage diff --git a/Packages/JSX/JSX (Inner).YAML-tmPreferences b/Packages/JSX/JSX (Inner).YAML-tmPreferences deleted file mode 100644 index f68bfad..0000000 --- a/Packages/JSX/JSX (Inner).YAML-tmPreferences +++ /dev/null @@ -1,9 +0,0 @@ -# [PackageDev] target_format: plist, ext: tmPreferences -name: JSX -scope: source.js meta.jsx.js - meta.embedded.expression -settings: - shellVariables: - - name: TM_COMMENT_START - value: '{/*' - - name: TM_COMMENT_END - value: '*/}' diff --git a/Packages/JSX/JSX (Outer).YAML-tmPreferences b/Packages/JSX/JSX (Outer).YAML-tmPreferences deleted file mode 100644 index d1e3052..0000000 --- a/Packages/JSX/JSX (Outer).YAML-tmPreferences +++ /dev/null @@ -1,16 +0,0 @@ -# [PackageDev] target_format: plist, ext: tmPreferences -name: JSX 2 -scope: source.js -settings: - # The indent patterns can't be limited to meta.jsx.js. Otherwise they wouldn't - # work for the outer most tag since it would fall outside of that scope. - # They're also not limited with '- string - comment' since you may be writing - # JSX in your documentation or template strings. - decreaseIndentPattern: >- - (?x) - ^\s*]+>$ - | ^\s*/>$ - increaseIndentPattern: >- - (?x) - ^\s*<[^/>]+>$ - | ^\s*<[^/>\s]+$ diff --git a/Packages/JSX/JavaScript (Babel).YAML-tmLanguage b/Packages/JSX/JavaScript (Babel).YAML-tmLanguage deleted file mode 100644 index 0b2a492..0000000 --- a/Packages/JSX/JavaScript (Babel).YAML-tmLanguage +++ /dev/null @@ -1,1467 +0,0 @@ -# [PackageDev] target_format: plist, ext: tmLanguage -name: JavaScript (Babel) -scopeName: source.js -fileTypes: [js, jsx, babel, es6] -firstLineMatch: ^#!\s*/.*\b(node|js)$\n? - -patterns: -- include: '#core' - -repository: - core: - patterns: - - include: '#literal-function-labels' - - include: '#literal-arrow-function-labels' - - include: '#literal-labels' - - - include: '#literal-for' - - include: '#literal-switch' - - - include: '#styled-components' # add support for styled-components - - include: '#graphql' - - - include: '#expression' - - include: '#literal-punctuation' - - expression: - patterns: - - include: '#merge-conflits' - - include: '#literal-regexp' # before operators and keywords to avoid ambiguities - - include: '#literal-jsx' - - include: '#es7-decorators' - - include: '#support-class' - - include: '#support-other' - - - include: '#literal-function' - - include: '#literal-arrow-function' - - include: '#literal-prototype' # after literal-function, which includes some prototype strings - - - include: '#literal-keywords' - - - include: '#literal-method' - - include: '#literal-module' - - include: '#literal-class' - - include: '#flowtype-declaration' - - - include: '#literal-number' # after literal-method since short methods can be numbers - - include: '#literal-template-string' - - include: '#literal-string' - - include: '#literal-language-constant' - - include: '#literal-language-variable' - - - include: '#literal-constructor' - - include: '#literal-method-call' - - include: '#literal-function-call' - - - include: '#comments' - - include: '#brackets' - - - include: '#literal-operators' - - include: '#literal-variable' - - round-brackets: - patterns: - - name: meta.group.braces.round.js - begin: \( - beginCaptures: - '0': {name: meta.brace.round.begin.js} - end: \) - endCaptures: - '0': {name: meta.brace.round.end.js} - patterns: - - include: '#expression' - - square-brackets: - patterns: - - name: meta.group.braces.square.js - begin: \[ - beginCaptures: - '0': {name: meta.brace.square.begin.js} - end: \] - endCaptures: - '0': {name: meta.brace.square.end.js} - patterns: - - include: '#expression' - - curly-brackets: - patterns: - - name: meta.group.braces.curly.js - begin: '{' - beginCaptures: - '0': {name: meta.brace.curly.begin.js} - end: '}' - endCaptures: - '0': {name: meta.brace.curly.end.js} - patterns: - - include: $self - - brackets: - patterns: - - include: '#round-brackets' - - include: '#square-brackets' - - include: '#curly-brackets' - - comments: - patterns: - - name: comment.block.documentation.js - begin: /\*\*(?!/) - captures: - '0': {name: punctuation.definition.comment.js} - end: \*/ - - - name: comment.block.js - begin: /\* - beginCaptures: - '0': {name: punctuation.definition.comment.begin.js} - end: \*/ - endCaptures: - '0': {name: punctuation.definition.comment.end.js} - - - name: comment.block.html.js - match: (?>) - captures: - '0': {name: punctuation.definition.comment.js} - - - name: comment.line.double-slash.js - match: (//).*$\n? - captures: - '1': {name: punctuation.definition.comment.js} - - - name: comment.line.shebang.js - match: ^(#!).*$\n? - captures: - '1': {name: punctuation.definition.comment.js} - - function-declaration-parameters: - patterns: - - begin: \( - beginCaptures: - '0': {name: punctuation.definition.parameters.begin.js} - end: \) - endCaptures: - '0': {name: punctuation.definition.parameters.end.js} - patterns: - - include: '#comments' - - include: '#flowtype-annotation' - - name: keyword.operator.spread.js - match: (?import|export|default|from|as)\b - - literal-class: - patterns: - # e.g. class MyClass { } - - name: meta.class.js - begin: (?; - # e.g. static (o: ?void): {[key: any]: any}; - # e.g. return(value: R): { done: true, value: R }; - # e.g. (o: T): T; - - name: meta.short-method.flowtype.js - begin: (@@[_$a-zA-Z][$\w]*|static|return)(?=\s*[<(])|(?=\s*<) - beginCaptures: - '1': {name: keyword.operator.flowtype.js} - end: (?=\s*[;{]) - patterns: - - include: '#flowtype-polymorph' - - include: '#function-declaration-parameters' - - include: '#flowtype-annotation' - - include: '#comments' - - include: '#curly-brackets' - - # In objects and flow annotations it can't be assumed that a start quote - # or start square-bracket is for a method - it may be a computed property. - # For multi-line quoted short methods and computed property methods, only - # the polymorphism constraints and parameters are matched. - - name: meta.class-method.computed.js - begin: (?<=[]"'])\s*(?=[<(]) - end: (?=\s*[;{]) - patterns: - - include: '#flowtype-polymorph' - - include: '#function-declaration-parameters' - - include: '#flowtype-annotation' - - include: '#comments' - - include: '#curly-brackets' - - - name: meta.class-accessor.js - begin: >- - (?x) - ((?>get|set)\s+) - (?> - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - (([_$a-zA-Z][$\w]*|\d+)) - )(?=\s*[<(]) - beginCaptures: - '1': {name: storage.type.js} - '2': {name: string.quoted.js} - '3': {name: punctuation.definition.string.begin.js} - '4': {name: entity.name.function.js} - '5': {name: punctuation.definition.string.end.js} - '6': {name: string.quoted.js} - '7': {name: punctuation.definition.string.begin.js} - '8': {name: entity.name.function.js} - '9': {name: punctuation.definition.string.end.js} - '10': {name: string.unquoted.js} - '11': {name: entity.name.function.js} - end: (?=\s*[;{]) - patterns: - - include: '#flowtype-polymorph' - - include: '#function-declaration-parameters' - - include: '#flowtype-annotation' - - include: '#comments' - - include: '#curly-brackets' - - - name: meta.class-method.js - begin: >- - (?x) - (?> - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - (([_$a-zA-Z][$\w]*|\d+)) - )(?=\s*[<(]) - beginCaptures: - '1': {name: string.quoted.js} - '2': {name: punctuation.definition.string.begin.js} - '3': {name: entity.name.function.js} - '4': {name: punctuation.definition.string.end.js} - '5': {name: string.quoted.js} - '6': {name: punctuation.definition.string.begin.js} - '7': {name: entity.name.function.js} - '8': {name: punctuation.definition.string.end.js} - '9': {name: string.unquoted.js} - '10': {name: entity.name.function.js} - end: (?=\s*[;{]) - patterns: - - include: '#flowtype-polymorph' - - include: '#function-declaration-parameters' - - include: '#flowtype-annotation' - - include: '#comments' - - include: '#curly-brackets' - - class-method-storage: - patterns: - - name: storage.modifier.js - match: (?static|declare)\b - - - name: storage.type.js - match: (?- - (?x) - (?:\b(static)\s+)? - (?:\b(async)\s+)? - (?:(\*)\s*)? - (?> - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - (([_$a-zA-Z][$\w]*|\d+)) - ) - (?=\s*(\((?>(?>[^()]+)|\g<-1>)*\))(?>\s|/\*.*\*/)*\{) - beginCaptures: - '1': {name: storage.type.js} - '2': {name: storage.type.js} - '3': {name: keyword.generator.asterisk.js} - '4': {name: string.quoted.js} - '5': {name: punctuation.definition.string.begin.js} - '6': {name: entity.name.function.js} - '7': {name: punctuation.definition.string.end.js} - '8': {name: string.quoted.js} - '9': {name: punctuation.definition.string.begin.js} - '10': {name: entity.name.function.js} - '11': {name: punctuation.definition.string.end.js} - '12': {name: string.unquoted.js} - '13': {name: entity.name.function.js} - end: (?<=\)) - patterns: - - include: '#function-declaration-parameters' - - # getter/setter - - name: meta.accessor.js - begin: >- - (?x) - \b(?:(static)\s+)? - (get|set)\s+ - ([_$a-zA-Z][$\w]*|\d+)\s* - (?=(\((?>(?>[^()]+)|\g<-1>)*\))(?>\s|/\*.*\*/)*\{) - beginCaptures: - '1': {name: storage.type.js} - '2': {name: storage.type.accessor.js} - '3': {name: entity.name.accessor.js} - end: (?<=\)) - patterns: - - include: '#function-declaration-parameters' - - literal-prototype: - patterns: - # e.g. Sound.prototype = { } when extending an object - - name: meta.prototype.declaration.js - match: ([_$a-zA-Z][$\w]*)(\.)(prototype)\s*(=)\s* - captures: - '1': {name: entity.name.class.js} - '2': {name: keyword.operator.accessor.js} - '3': {name: variable.language.prototype.js} - '4': {name: keyword.operator.assignment.js} - - # e.g. Sound.prototype - - name: meta.prototype.access.js - match: ([_$a-zA-Z][$\w]*)(\.)(prototype)\b - captures: - '1': {name: entity.name.class.js} - '2': {name: keyword.operator.accessor.js} - '3': {name: variable.language.prototype.js} - - literal-function: - patterns: - # e.g. function play(arg1, arg2) { } - # e.g. play = function(arg1, arg2) { } - - name: meta.function.js - begin: >- - (?x) - (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? - (?:(async)\s+)? - (function)(?>\s*(\*)|(?=[\s(<])) - \s*([_$a-zA-Z][$\w]*)? - beginCaptures: - '1': {name: entity.name.function.js} - '2': {name: keyword.operator.assignment.js} - '3': {name: storage.type.js} - '4': {name: storage.type.function.js} - '5': {name: keyword.generator.asterisk.js} - '6': {name: entity.name.function.js} - end: (?<=\)) - patterns: - - include: '#flowtype-polymorph' - - include: '#function-declaration-parameters' - - # e.g. Sound.prototype.play = function(arg1, arg2) { } - - name: meta.function.prototype.js - begin: >- - (?x) - (\b_?[A-Z][$\w]*)? - (\.)(prototype) - (\.)([_$a-zA-Z][$\w]*) - \s*(=) - \s*(?:(async)\s+)? - \s*(function)(?>\s*(\*)|(?=[\s(<])) - \s*([_$a-zA-Z][$\w]*)?\s* - beginCaptures: - '1': {name: entity.name.class.js} - '2': {name: keyword.operator.accessor.js} - '3': {name: variable.language.prototype.js} - '4': {name: keyword.operator.accessor.js} - '5': {name: entity.name.function.js} - '6': {name: keyword.operator.assignment.js} - '7': {name: storage.type.js} - '8': {name: storage.type.function.js} - '9': {name: keyword.generator.asterisk.js} - '10': {name: entity.name.function.js} - end: (?<=\)) - patterns: - - include: '#flowtype-polymorph' - - include: '#function-declaration-parameters' - - # e.g. Sound.play = function(arg1, arg2) { } - - name: meta.function.static.js - begin: >- - (?x) - (\b_?[A-Z][$\w]*)? - (\.)([_$a-zA-Z][$\w]*) - \s*(=) - \s*(?:(async)\s+)? - \s*(function)(?>\s*(\*)|(?=[\s(<])) - \s*([_$a-zA-Z][$\w]*)?\s* - beginCaptures: - '1': {name: entity.name.class.js} - '2': {name: keyword.operator.accessor.js} - '3': {name: entity.name.function.js} - '4': {name: keyword.operator.assignment.js} - '5': {name: storage.type.js} - '6': {name: storage.type.function.js} - '7': {name: keyword.generator.asterisk.js} - '8': {name: entity.name.function.js} - end: (?<=\)) - patterns: - - include: '#flowtype-polymorph' - - include: '#function-declaration-parameters' - - literal-function-labels: - patterns: - # e.g. play: function(arg1, arg2) { } - # e.g. "play": function(arg1, arg2) { } - - name: meta.function.json.js - begin: >- - (?x) - (?> - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - (([_$a-zA-Z][$\w]*|\d+)) - ) - \s*(:) - \s*(?:\b(async)\s+)? - \s*(function)(?>\s*(\*)|(?=[\s(<])) - \s*([_$a-zA-Z][$\w]*)? - beginCaptures: - '1': {name: string.quoted.js} - '2': {name: punctuation.definition.string.begin.js} - '3': {name: entity.name.function.js} - '4': {name: punctuation.definition.string.end.js} - '5': {name: string.quoted.js} - '6': {name: punctuation.definition.string.begin.js} - '7': {name: entity.name.function.js} - '8': {name: punctuation.definition.string.end.js} - '9': {name: string.unquoted.js} - '10': {name: entity.name.function.js} - '11': {name: punctuation.separator.key-value.js} - '12': {name: storage.type.js} - '13': {name: storage.type.function.js} - '14': {name: keyword.generator.asterisk.js} - '15': {name: entity.name.function.js} - end: (?<=\)) - patterns: - - include: '#flowtype-polymorph' - - include: '#function-declaration-parameters' - - literal-arrow-function: - patterns: - # e.g. (args) => { } - # e.g. play = (args) => { } - - name: meta.function.arrow.js - begin: >- - (?x) - (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? - (?:\b(async)\s+)? - (?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) - beginCaptures: - '1': {name: entity.name.function.js} - '2': {name: keyword.operator.assignment.js} - '3': {name: storage.type.js} - end: (?<=\))\s*(=>) - endCaptures: - '1': {name: storage.type.function.arrow.js} - patterns: - - include: '#function-declaration-parameters' - - # e.g. arg => { } - # e.g. play = arg => { } - - name: meta.function.arrow.js - match: >- - (?x) - (?:([_$a-zA-Z][$\w]*)\s*(=)\s*)? - (?:(async)\s+)? - \b([_$a-zA-Z][$\w]*)\s*(=>) - captures: - '1': {name: entity.name.function.js} - '2': {name: keyword.operator.assignment.js} - '3': {name: storage.type.js} - '4': {name: variable.parameter.function.js} - '5': {name: storage.type.function.arrow.js} - - # e.g. Sound.prototype.play = (args) => { } - - name: meta.prototype.function.arrow.js - begin: >- - (?x) - (\b_?[A-Z][$\w]*)? - (\.)(prototype) - (\.)([_$a-zA-Z][$\w]*) - \s*(=) - \s*(async)? - \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) - beginCaptures: - '1': {name: entity.name.class.js} - '2': {name: keyword.operator.accessor.js} - '3': {name: variable.language.prototype.js} - '4': {name: keyword.operator.accessor.js} - '5': {name: entity.name.function.js} - '6': {name: keyword.operator.assignment.js} - '7': {name: storage.type.js} - end: (?<=\))\s*(=>) - endCaptures: - '1': {name: storage.type.function.arrow.js} - patterns: - - include: '#function-declaration-parameters' - - # e.g. Sound.prototype.play = arg => { } - - name: meta.prototype.function.arrow.js - match: >- - (?x) - (\b_?[A-Z][$\w]*)? - (\.)(prototype) - (\.)([_$a-zA-Z][$\w]*) - \s*(=) - \s*(async)? - \s*\b([_$a-zA-Z][$\w]*)\s*(=>) - captures: - '1': {name: entity.name.class.js} - '2': {name: keyword.operator.accessor.js} - '3': {name: variable.language.prototype.js} - '4': {name: keyword.operator.accessor.js} - '5': {name: entity.name.function.js} - '6': {name: keyword.operator.assignment.js} - '7': {name: storage.type.js} - '8': {name: variable.parameter.function.js} - '9': {name: storage.type.function.arrow.js} - - # e.g. Sound.play = (args) => { } - - name: meta.function.static.arrow.js - begin: >- - (?x) - (\b_?[A-Z][$\w]*)? - (\.)([_$a-zA-Z][$\w]*) - \s*(=) - \s*(async)? - \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) - beginCaptures: - '1': {name: entity.name.class.js} - '2': {name: keyword.operator.accessor.js} - '3': {name: entity.name.function.js} - '4': {name: keyword.operator.assignment.js} - '5': {name: storage.type.js} - end: (?<=\))\s*(=>) - endCaptures: - '1': {name: storage.type.function.arrow.js} - patterns: - - include: '#function-declaration-parameters' - - # e.g. Sound.play = arg => { } - - name: meta.function.static.arrow.js - match: >- - (?x) - (\b_?[A-Z][$\w]*)? - (\.)([_$a-zA-Z][$\w]*) - \s*(=) - \s*(async)? - \s*\b([_$a-zA-Z][$\w]*)\s*(=>) - captures: - '1': {name: entity.name.class.js} - '2': {name: keyword.operator.accessor.js} - '3': {name: entity.name.function.js} - '4': {name: keyword.operator.assignment.js} - '5': {name: storage.type.js} - '6': {name: variable.parameter.function.js} - '7': {name: storage.type.function.arrow.js} - - literal-arrow-function-labels: - patterns: - # e.g. play: (args) => { } - # e.g. "play": (args) => { } - - name: meta.function.json.arrow.js - begin: >- - (?x) - (?> - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - (([_$a-zA-Z][$\w]*|\d+)) - ) - \s*(:) - \s*(?:\b(async)\s+)? - \s*(?=(\((?>(?>[^()]+)|\g<-1>)*\))\s*(=>)) - beginCaptures: - '1': {name: string.quoted.js} - '2': {name: punctuation.definition.string.begin.js} - '3': {name: entity.name.function.js} - '4': {name: punctuation.definition.string.end.js} - '5': {name: string.quoted.js} - '6': {name: punctuation.definition.string.begin.js} - '7': {name: entity.name.function.js} - '8': {name: punctuation.definition.string.end.js} - '9': {name: string.unquoted.js} - '10': {name: entity.name.function.js} - '11': {name: punctuation.separator.key-value.js} - '12': {name: storage.type.js} - end: (?<=\))\s*(=>) - endCaptures: - '1': {name: storage.type.function.arrow.js} - patterns: - - include: '#function-declaration-parameters' - - # e.g. play: arg => { } - # e.g. "play": arg => { } - - name: meta.function.json.arrow.js - match: >- - (?x) - (?> - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - (([_$a-zA-Z][$\w]*|\d+)) - ) - \s*(:) - \s*(?:\b(async)\s+)? - \s*\b([_$a-zA-Z][$\w]*)\s*(=>) - captures: - '1': {name: string.quoted.js} - '2': {name: punctuation.definition.string.begin.js} - '3': {name: entity.name.function.js} - '4': {name: punctuation.definition.string.end.js} - '5': {name: string.quoted.js} - '6': {name: punctuation.definition.string.begin.js} - '7': {name: entity.name.function.js} - '8': {name: punctuation.definition.string.end.js} - '9': {name: string.unquoted.js} - '10': {name: entity.name.function.js} - '11': {name: punctuation.separator.key-value.js} - '12': {name: storage.type.js} - '13': {name: variable.parameter.function.js} - '14': {name: storage.type.function.arrow.js} - - literal-function-call: - patterns: - - name: meta.function-call.without-arguments.js - match: ([_$a-zA-Z][$\w]*)\s*(\(\s*\)) - captures: - '1': {name: variable.function.js} - '2': {name: meta.group.braces.round.function.arguments.js} - - - name: meta.function-call.with-arguments.js - match: ([_$a-zA-Z][$\w]*)\s*(?=\() - captures: - '1': {name: variable.function.js} - - - name: meta.function-call.tagged-template.js - match: ([_$a-zA-Z][$\w]*)\s*(?=`) - captures: - '1': {name: variable.function.js} - - literal-method-call: - patterns: - - name: meta.function-call.static.without-arguments.js - match: >- - (?x) - (?:(?<=\.)|\b) - ([A-Z][$\w]*)\s*(\.) - ([_$a-zA-Z][$\w]*)\s* - (\(\s*\)) - captures: - '1': {name: variable.other.class.js} - '2': {name: keyword.operator.accessor.js} - '3': {name: variable.function.js} - '4': {name: meta.group.braces.round.function.arguments.js} - - - name: meta.function-call.static.with-arguments.js - match: >- - (?x) - (?:(?<=\.)|\b) - ([A-Z][$\w]*)\s*(\.) - ([_$a-zA-Z][$\w]*)\s* - (?=\() - captures: - '1': {name: variable.other.class.js} - '2': {name: keyword.operator.accessor.js} - '3': {name: variable.function.js} - - - name: meta.function-call.method.without-arguments.js - match: >- - (?x) - (?<=\.) - ([_$a-zA-Z][$\w]*)\s* - (\(\s*\)) - captures: - '1': {name: variable.function.js} - '2': {name: meta.group.braces.round.function.arguments.js} - - - name: meta.function-call.method.with-arguments.js - match: >- - (?x) - (?<=\.) - ([_$a-zA-Z][$\w]*)\s* - (?=\() - captures: - '1': {name: variable.function.js} - - literal-language-variable: - patterns: - - name: variable.language.arguments.js - match: (?const|let|var)\b - - literal-keywords: - patterns: - - include: '#literal-keyword-storage' - - - match: (?await|yield))\b(?:\s*(\*))? - captures: - '1': {name: keyword.control.flow.js} - '2': {name: keyword.generator.asterisk.js} - - - name: keyword.control.flow.js - match: (?if|else)\b - - - name: keyword.control.trycatch.js - match: (?catch|finally|throw|try)\b - - - name: keyword.control.loop.js - match: (?break|continue|do|goto|while|case|default)\b - - - name: keyword.other.reserved.js - match: (?enum|module|public|package|private|interface|protected)\b - - - name: keyword.other.js - match: (?delete|instanceof|in|new|of|typeof|void|with)\b - - - name: keyword.operator.logical.js - match: >- - (?x) - !(?!=)| # logical-not right-to-left right - && | # logical-and left-to-right both - \|\| # logical-or left-to-right both - - - name: keyword.operator.assignment.js - match: >- - (?x) - =(?!=) # assignment right-to-left both - - - name: keyword.operator.assignment.augmented.js - match: >- - (?x) - %= | # assignment right-to-left both - &= | # assignment right-to-left both - \*= | # assignment right-to-left both - \+= | # assignment right-to-left both - -= | # assignment right-to-left both - /= | # assignment right-to-left both - \^= | # assignment right-to-left both - \|= | # assignment right-to-left both - <<= | # assignment right-to-left both - >>= | # assignment right-to-left both - >>>= # assignment right-to-left both - - - name: keyword.operator.bitwise.js - match: >- - (?x) - ~ | # bitwise-not right-to-left right - << | # bitwise-shift left-to-right both - >>> | # bitwise-shift left-to-right both - >> | # bitwise-shift left-to-right both - & | # bitwise-and left-to-right both - \^ | # bitwise-xor left-to-right both - \| # bitwise-or left-to-right both - - - name: keyword.operator.relational.js - match: >- - (?x) - <= | # relational left-to-right both - >= | # relational left-to-right both - < | # relational left-to-right both - > # relational left-to-right both - - - name: keyword.operator.comparison.js - match: >- - (?x) - === | # equality left-to-right both - !== | # equality left-to-right both - == | # equality left-to-right both - != # equality left-to-right both - - - name: keyword.operator.arithmetic.js - match: >- - (?x) - -- | # decrement n/a right-or-left - \+\+ | # increment n/a right-or-left - / | # division left-to-right both - % | # modulus left-to-right both - \* | # multiplication left-to-right both - \+ | # addition left-to-right both - - # subtraction left-to-right both - - - name: keyword.operator.ternary.js - match: '[?:]' - - - name: keyword.operator.spread.js - match: (?- - (?x) - (? - ((')((?>[^'\\]|\\.)*)('))| - ((")((?>[^"\\]|\\.)*)("))| - )\s*:) - end: ':' - endCaptures: - '0': {name: punctuation.separator.key-value.js} - patterns: - - include: '#literal-string' - - - name: constant.other.object.key.js - match: (?- - (?xi) - (?:\B[-+])? - (?: - \b0b[0-1]*| # binary - \b0o[0-7]*| # octal - \b0x[0-9a-f]*| # hex - ( - \B\.[0-9]+| # e.g. .999 - \b[0-9]+(\.[0-9]*)? # e.g. 999.999, 999. or 999 - )(e[-+]?[0-9]+)? # e.g. e+123, E-123 - ) - - - name: constant.language.infinity.js - match: (?:\B[-+]|\b)(Infinity)\b - - literal-punctuation: - patterns: - - name: punctuation.terminator.statement.js - match: ; - - - name: meta.delimiter.comma.js - match: ',' - - literal-regexp: - patterns: - # ignore ++, -- since they're uncommon, distinguishing them is not possible in sublime text, see: - # http://stackoverflow.com/questions/5519596/when-parsing-javascript-what-determines-the-meaning-of-a-slash - - name: string.regexp.js - begin: >- - (?x) - (?<= - \.|\(|,|{|}|\[|;|<|>|<=|>=|==|!=|===|!==|\+|-|\*|%|\+\+|--|<<|>>|>>>|&|\||\^|!|~|&&|\|\||\?|:|=|\+=|-=|\*=|%=|<<=|>>=|>>>=|&=|\|=|\^=|/|/=| - \Wnew|\Wdelete|\Wvoid|\Wtypeof|\Winstanceof|\Win|\Wdo|\Wreturn|\Wcase|\Wthrow|\Wyield| - ^new|^delete|^void|^typeof|^instanceof|^in|^do|^return|^case|^throw|^yield|^ - )\s* - (/) - (?!/|\*|$) - beginCaptures: - '1': {name: punctuation.definition.string.begin.js} - end: (/)([gimy]*) - endCaptures: - '1': {name: punctuation.definition.string.end.js} - '2': {name: keyword.other.js} - patterns: - - include: source.regexp.js - - literal-string: - patterns: - - name: string.quoted.js - begin: (["']) - beginCaptures: - '0': {name: punctuation.definition.string.begin.js} - end: (\1)|(\n) - endCaptures: - '1': {name: punctuation.definition.string.end.js} - '2': {name: invalid.illegal.newline.js} - patterns: - - include: '#string-content' - - literal-template-string: - begin: '`' - beginCaptures: - '0': {name: string.interpolated.js keyword.other.template.begin.js} - end: '`' - captures: - '0': {name: string.interpolated.js keyword.other.template.end.js} - patterns: - - include: '#string-content' - - name: constant.character.escape.js - match: \\` - - begin: \${ - beginCaptures: - '0': {name: keyword.other.substitution.begin.js} - end: '}' - endCaptures: - '0': {name: keyword.other.substitution.end.js} - patterns: - - include: '#expression' - # Workaround so themes color the contents of template strings as "string", - # but not any interpolated expression within. - - name: string.interpolated.js - match: '.' - - string-content: - # https://mathiasbynens.be/notes/javascript-escapes - patterns: - - name: constant.character.escape.newline.js - match: \\\s*\n - - - name: constant.character.escape.js - match: \\([1-7][0-7]{0,2}|[0-7]{2,3}|[bfnrtv0'"\\]|x\h{2}|u\{\h+\}|u\h{4}) - - # https://github.com/styled-components/styled-components - styled-components: - patterns: - - name: meta.styled-components.js - begin: (?(?>[^()]+)|\g<-1>)*\))\s*`) - captures: - '1': {name: meta.function-call.with-arguments.js variable.function.js} - end: (?<=`) - patterns: - # Like #round-brackets, but with "meta.function-call.with-arguments.js" so - # it can stop before the template starts. - - name: meta.function-call.with-arguments.js meta.group.js - begin: \( - beginCaptures: - '0': {name: punctuation.definition.group.begin.js} - end: \) - endCaptures: - '0': {name: punctuation.definition.group.end.js} - patterns: - - include: '#expression' - - begin: '`' - beginCaptures: - '0': {name: punctuation.definition.string.template.begin.js} - end: '`' - contentName: source.css.embedded.js - endCaptures: - '0': {name: punctuation.definition.string.template.end.js} - patterns: - - include: source.js.css - - graphql: - patterns: - - name: meta.graphql.js - begin: '\s*+gql`' - end: '`' - patterns: - - include: source.graphql - - name: js - begin: '\${' - end: '}' - patterns: - - include: '#core' - - - name: meta.graphql.js - begin: '\s*+`#graphql' - end: '`' - patterns: - - include: source.graphql - - name: js - begin: '\${' - end: '}' - patterns: - - include: '#core' - - - literal-variable: - patterns: - # e.g. CONSTANT - - name: variable.other.constant.js - match: _*?[A-Z][_$\dA-Z]*\b - - # e.g. Class.property - - name: meta.property.class.js - match: \b([A-Z][$\w]*)\s*(\.)([_$a-zA-Z][$\w]*) - captures: - '1': {name: variable.other.class.js} - '2': {name: keyword.operator.accessor.js} - '3': {name: variable.other.property.static.js} - - # e.g. obj.property - - name: variable.other.object.js - match: (?Eval|Range|Reference|Syntax|Type|URI)?Error)\b - - - name: support.class.node.js - match: \b(?>Buffer)\b - - support-other: - patterns: - - name: support.function.builtin.js - match: (?document|window)\b - - - name: support.type.object.node.js - match: (?global|GLOBAL|root|__dirname|__filename)\b - - - match: (?|\Wreturn|^return|\Wdefault|^)(?=\s*<[_$a-zA-Z]) - end: (?<=/>|>) - patterns: - - include: '#jsx-tag-start' - - jsx-tag-start: - patterns: - - begin: (<)([_$a-zA-Z][-$:.\w]*[$\w]*) - beginCaptures: - '1': {name: meta.tag.jsx punctuation.definition.tag.begin.jsx} - '2': {name: meta.tag.jsx entity.name.tag.jsx} - end: ()|(/>) - endCaptures: - '1': {name: meta.tag.jsx punctuation.definition.tag.begin.jsx} - '2': {name: meta.tag.jsx entity.name.tag.jsx} - '3': {name: meta.tag.jsx punctuation.definition.tag.end.jsx} - '4': {name: meta.tag.jsx punctuation.definition.tag.end.jsx} - patterns: - - include: '#jsx-tag-end' - - include: '#jsx-attributes' - - - name: invalid.illegal.tag.incomplete.jsx - match: '<' - - jsx-tag-end: - begin: '>' - beginCaptures: - '0': {name: meta.tag.jsx punctuation.definition.tag.end.jsx} - end: (?=- - (?x) - (@)([_$a-zA-Z][$\w]*)\b - captures: - '1': {name: punctuation.definition.tag.js} - '2': {name: entity.name.tag.js} - - merge-conflits: - patterns: - - match: ^([<]{7})\s(.+)$ - captures: - '1': {name: invalid.illegal.conflict-marker.merge-into.js} - '2': {name: invalid.illegal.string.js} - - match: ^([=|]{7})$ - captures: - '1': {name: invalid.illegal.conflict-marker.separator.js} - - match: ^([>]{7})\s(.+)$ - captures: - '1': {name: invalid.illegal.conflict-marker.other-commit.js} - '2': {name: invalid.illegal.string.js} - - flowtype-polymorph: - # http://flowtype.org/blog/2015/03/12/Bounded-Polymorphism.html - name: meta.flowtype.polymorph.js - begin: '<' - beginCaptures: - '0': {name: punctuation.section.flowtype.begin.js} - end: '>' - endCaptures: - '0': {name: punctuation.section.flowtype.end.js} - patterns: - - include: '#flowtype-tokens' - - flowtype-annotation: - patterns: - - name: meta.flowtype.annotation.js - begin: (?:(\?)\s*)?(:) - beginCaptures: - '1': {name: keyword.operator.flowtype.optional.js} - '2': {name: keyword.operator.flowtype.annotation.js} - end: (?=\S) - applyEndPatternLast: 1 - patterns: - - include: '#flowtype-tokens' - - flowtype-brackets: - patterns: - - begin: '{' - beginCaptures: - '0': {name: punctuation.section.flowtype.begin.js} - end: '}' - endCaptures: - '0': {name: punctuation.section.flowtype.end.js} - patterns: - - include: '#flowtype-tokens' - - flowtype-identifier: - patterns: - - include: '#support-class' - - - name: constant.other.primitve.flowtype.js - match: \b(?:any|bool|boolean|mixed|number|string|void)\b - - - name: variable.other.flowtype.js - match: '[_$a-zA-Z][$\w]*' - - - name: keyword.operator.flowtype.optional.js - match: \? - - flowtype-tokens: - patterns: - - begin: (?<=[:?|&=])(?=\s*{) - end: (?<=}) - patterns: - - include: '#flowtype-brackets' - - - name: meta.flowtype.set.js - match: \s*([|&])\s* - captures: - '1': {name: keyword.operator.flowtype.other.js} - - - name: keyword.operator.flowtype.other.js - match: '[*:?&|.]|\.\.\.|\b(typeof)\b' - - - begin: '<' - beginCaptures: - '0': {name: punctuation.section.flowtype.begin.js} - end: '>' - endCaptures: - '0': {name: punctuation.section.flowtype.end.js} - patterns: - - include: '#flowtype-tokens' - - - begin: \[ - beginCaptures: - '0': {name: punctuation.section.flowtype.begin.js} - end: \] - endCaptures: - '0': {name: punctuation.section.flowtype.end.js} - patterns: - - include: '#flowtype-tokens' - - - begin: \( - beginCaptures: - '0': {name: punctuation.section.flowtype.begin.js} - end: \) - endCaptures: - '0': {name: punctuation.section.flowtype.end.js} - patterns: - - include: '#flowtype-tokens' - - - name: meta.flowtype.function.js - begin: '=>' - beginCaptures: - '0': {name: keyword.operator.flowtype.js} - end: (?<=}|[_$a-zA-Z]) - patterns: - - include: '#flowtype-brackets' - - include: '#flowtype-identifier' - - include: '#comments' - - - include: '#flowtype-identifier' - - include: '#literal-string' - - include: '#comments'