diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..0de9406f --- /dev/null +++ b/.gitattributes @@ -0,0 +1,7 @@ +# Make sure baseline files have consistent line endings +*.txt text eol=lf + +# Override classification +*.YAML-tmLanguage linguist-language=YAML +*.YAML-tmTheme linguist-language=YAML +*.YAML-tmPreferences linguist-language=YAML diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 00000000..4f023193 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,17 @@ +--- +name: Bug report +about: Create a report to help us improve +title: '' +labels: '' +assignees: '' + +--- + +**[JavaScript and TypeScript Nightly](https://marketplace.visualstudio.com/items?itemName=ms-vscode.vscode-typescript-next) version:** + +**Code** + +```ts +// Please include a code snippet that demonstrates the issue + +``` diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml new file mode 100644 index 00000000..b5ef56ca --- /dev/null +++ b/.github/workflows/CI.yml @@ -0,0 +1,33 @@ +name: CI +on: + push: + branches: + - main + - master + pull_request: + branches: + - main + - master + +jobs: + tests: + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-latest, windows-latest, macos-latest] + # Test the latest version of Node.js plus the last two LTS versions. + node-version: + - "*" + - lts/* + - lts/-1 + + steps: + - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 + - name: Use node version ${{ matrix.node-version }} + uses: actions/setup-node@2028fbc5c25fe9cf00d9f06a71cc4710d4507903 # v6.0.0 + with: + node-version: ${{ matrix.node-version }} + check-latest: true + - run: npm i + - run: npm test + diff --git a/.github/workflows/accept-baselines.yml b/.github/workflows/accept-baselines.yml new file mode 100644 index 00000000..ae5e0c9a --- /dev/null +++ b/.github/workflows/accept-baselines.yml @@ -0,0 +1,25 @@ +name: Accept Baselines + +on: + workflow_dispatch: {} + +jobs: + build: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 + - uses: actions/setup-node@2028fbc5c25fe9cf00d9f06a71cc4710d4507903 # v6.0.0 + + - name: Configure Git, Run Tests, Update Baselines + run: | + git config user.email "typescriptbot@microsoft.com" + git config user.name "TypeScript Bot" + npm install + git rm -r --quiet tests/baselines + npm test + npm run accept + git add ./tests/baselines + git diff --cached + git commit -m "Update Baselines" + git push diff --git a/.gitignore b/.gitignore index 4c566d18..8f0231b6 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,6 @@ +node_modules +build/*.js +tests/*.js tests/generated/* -tests/node_modules -tests/typings/ -tests/*.js \ No newline at end of file +xunit.xml +*.tsbuildinfo diff --git a/.vscode/settings.json b/.vscode/settings.json index 765a941b..c1950c38 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,4 +1,9 @@ // Place your settings in this file to overwrite default and user settings. { - "editor.insertSpaces": true + "editor.insertSpaces": true, + "files.associations": { + "*.YAML-tmLanguage": "yaml", + "*.YAML-tmPreferences": "yaml", + "*.YAML-tmTheme": "yaml" + } } \ No newline at end of file diff --git a/Comments.tmPreferences b/Comments.tmPreferences index 9b052b0b..e5077373 100644 --- a/Comments.tmPreferences +++ b/Comments.tmPreferences @@ -31,6 +31,6 @@ uuid - A67A8BD9-A951-406F-9175-018DD4B52FD1 + FF9A09B1-D1C3-4AF0-9A11-2EC300F03184 diff --git a/LICENSE.txt b/LICENSE.txt index 2bb9ad24..45aa2b68 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -1,176 +1,22 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS \ No newline at end of file +Copyright (c) Microsoft Corporation +All rights reserved. + +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. \ No newline at end of file diff --git a/README.md b/README.md index 485f9ec6..5d475e33 100644 --- a/README.md +++ b/README.md @@ -1,18 +1,32 @@ # TypeScript-TmLanguage -[![Build status](https://ci.appveyor.com/api/projects/status/i7fp97q9nc5uw5kf?svg=true)](https://ci.appveyor.com/project/zhengbli/typescript-tmlanguage) +[![GitHub Actions CI](https://github.com/microsoft/TypeScript-TmLanguage/workflows/CI/badge.svg)](https://github.com/microsoft/TypeScript-TmLanguage/actions?query=workflow%3ACI) This repository contains TmLanguage files that are consumed by TypeScript editors and plugins such as [Visual Studio Code](https://github.com/Microsoft/vscode), [The TypeScript Sublime Plugin](https://github.com/Microsoft/TypeScript-Sublime-Plugin), [Atom TypeScript](https://github.com/TypeStrong/atom-typescript), and possibly others. +Latest version of the grammar can be also found as a [VSCode extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode.vscode-typescript-next). + # Contributing -The XML files are generated from the YAML files, so contributors should hand-modify the YAML files, and XML files should only be generated by the [AAAPackageDev](https://github.com/SublimeText/AAAPackageDev) plugin. +The XML files are generated from the YAML files, so contributors should hand-modify the YAML files, and XML files should only be generated by running build script. -## Tests +## Install dependencies +``` sh +npm install +``` + +## Build -Test are run from within the ```tests``` folder +Compile the yaml file into the tmLanguage and tmTheme files + +``` sh +npm run build:grammar +``` + +## Tests ``` sh -cd tests -npm install # Installs dependencies required for testing npm test # Compiles & runs tests + +npm run diff # Diffs the test baselines with generated one using tool set in environment variable DIFF +npm run accept # Accepts the test baselines ``` diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 00000000..869fdfe2 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,41 @@ + + +## Security + +Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/). + +If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below. + +## Reporting Security Issues + +**Please do not report security vulnerabilities through public GitHub issues.** + +Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report). + +If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com). If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey). + +You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc). + +Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue: + + * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.) + * Full paths of source file(s) related to the manifestation of the issue + * The location of the affected source code (tag/branch/commit or direct URL) + * Any special configuration required to reproduce the issue + * Step-by-step instructions to reproduce the issue + * Proof-of-concept or exploit code (if possible) + * Impact of the issue, including how an attacker might exploit the issue + +This information will help us triage your report more quickly. + +If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs. + +## Preferred Languages + +We prefer all communications to be in English. + +## Policy + +Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd). + + diff --git a/ThirdPartyNotices.txt b/ThirdPartyNotices.txt new file mode 100644 index 00000000..8a6aaeed --- /dev/null +++ b/ThirdPartyNotices.txt @@ -0,0 +1,54 @@ + +THIRD-PARTY SOFTWARE NOTICES AND INFORMATION +Do Not Translate or Localize + +Latest TypeScript and Javascript Grammar incorporates third party material from the projects listed below. The original copyright notice and the license under which Microsoft received such third party material are set forth below. Microsoft reserves all other rights not expressly granted, whether by implication, estoppel or otherwise. + +1. babel-sublime (https://github.com/babel/babel-sublime) +2. language-javascript (https://github.com/atom/language-javascript) + + +%% babel-sublime NOTICES, INFORMATION, AND LICENSE BEGIN HERE +========================================= +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. +========================================= +END OF babel-sublime NOTICES, INFORMATION, AND LICENSE + +%% language-javascript NOTICES, INFORMATION, AND LICENSE BEGIN HERE +========================================= +Copyright (c) 2015 GitHub Inc. + +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. + +This package was derived from a TextMate bundle located at https://github.com/textmate/javascript.tmbundle and distributed under the following license, located in README.mdown: + +Permission to copy, use, modify, sell and distribute this software is granted. This software is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose. +========================================= +END OF language-javascript NOTICES, INFORMATION, AND LICENSE + + diff --git a/TypeScript.YAML-tmLanguage b/TypeScript.YAML-tmLanguage index 5ea5d573..36fa5547 100644 --- a/TypeScript.YAML-tmLanguage +++ b/TypeScript.YAML-tmLanguage @@ -5,378 +5,2409 @@ scopeName: source.ts fileTypes: [ts] uuid: ef98eb90-bf9b-11e4-bb52-0800200c9a66 +variables: + startOfIdentifier: (?]|\|\||\&\&|\!\=\=|$' + matchingParenthesis: (\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\)) + matchingBraces: (\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\}) + matchingBrackets: (\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]) + inlineComment: \/\*([^\*]|(\*[^\/]))*\*\/ + startOfDeclaration: '{{startOfIdentifier}}(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?' + lookBehindOfPossiblyMultilineArrowWithDestructuring: (?<=[(=,]) + lookBehindOfPossiblyMultilineArrow: (?<=[(=,]|=>|{{lookBehindReturn}}) + lookBehindOfObjectMemberPossiblyMultilineArrow: (?<=:) + # Identifier start | matching braces | matching parenthesis | matching square brackets + typeParamersStart: (((const\s+)?[_$[:alpha:]])|{{matchingBraces}}|{{matchingParenthesis}}|{{matchingBrackets}}) + typeParameters: (<\s*{{typeParamersStart}}([^=<>]|=[^<]|\<\s*{{typeParamersStart}}([^=<>]|=[^<]|\<\s*{{typeParamersStart}}([^=<>]|=[^<])*\>)*\>)*>\s*) + # Identifier start | matching braces | matching parenthesis | matching square brackets | matching strings + typeArgumentsStart: (((keyof|infer|typeof|readonly)\s+)|(({{identifier}}|{{matchingBraces}}|{{matchingParenthesis}}|{{matchingBrackets}}|{{quotedStrings}})(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|))))) + typeArgumentsInnerExpressionPart: '[^<>\(]|{{matchingParenthesis}}|(?<==)\>' + typeArguments: '<\s*{{typeArgumentsStart}}({{typeArgumentsInnerExpressionPart}}|\<\s*{{typeArgumentsStart}}(({{typeArgumentsInnerExpressionPart}}|\<\s*{{typeArgumentsStart}}({{typeArgumentsInnerExpressionPart}})*(?))*(?)*(?' + possiblyMultilineTypeArgument: (<\s*[\{\[\(]\s*$) + functionCallLookup: \s*(?:(\?\.\s*)|(\!))?(({{typeArguments}}\s*)?\() + functionCallNamedTarget: (({{identifier}})(\s*{{propertyAccessPreIdentifier}}({{propertyIdentifier}}))*)|({{propertyAccessPreIdentifier}}{{propertyIdentifier}}) + functionCallTarget: (({{functionCallNamedTarget}})|(?<=[\)])) + possiblyMultilineCallWithTypeArguments: \s*(?:(\?\.\s*)|(\!))?{{possiblyMultilineTypeArgument}} + possiblyType: \s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+ + typeparamertStartOfArrow: '' + arrowLookup: |- + # sure shot arrow functions even if => is on new line + ( + {{typeParameters}}? + [(]\s*({{inlineComment}}\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?{{identifier}}\s*:) # [(]param: | [(]...param: + ) + ) | + {{typeparamertStartOfArrow}} + # arrow function possible to detect only with => on same line + ( + {{typeParameters}}? # typeparameters + \(\s*({{inlineComment}}\s*)*(([_$[:alpha:]]|{{matchingBraces}}|{{matchingBrackets}}|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|{{matchingParenthesis}}|{{quotedStrings}})*)?\) # parameters + (\s*:{{possiblyType}})? # return type + \s*=> # arrow operator + ) + possiblyMultilineArrowExpressionBeforeEndOfLine: ((({{typeParameters}})?\()|(<)|({{typeParameters}})) + possiblyMultilineObjectBindingPattern: '{{matchingBraces}}\s*((:\s*\{?$)|(({{possiblyType}}\s*)?=\s*))' + possiblyMultilineArrayBindingPattern: '{{matchingBrackets}}\s*((:\s*\[?$)|(({{possiblyType}}\s*)?=\s*))' + possiblyMultilineArrowWParamters: '((([\{\[]\s*)?$)|({{possiblyMultilineObjectBindingPattern}})|({{possiblyMultilineArrayBindingPattern}}))' + possiblyMultilineArrowWithoutTypeParameters: '[\(]\s*{{possiblyMultilineArrowWParamters}}' + possiblyMultilineArrow: ((<\s*$)|({{typeParameters}}?{{possiblyMultilineArrowWithoutTypeParameters}})) # during lookup treat ?( followed by line end as arrow or < followed by new line + functionOrArrowLookup: |- + \s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ({{identifier}}\s*=>) + )) | + ((async\s*)?( + {{possiblyMultilineArrow}} | + {{arrowLookup}} + )) + ) + functionLikeType: |- + (:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) + )) | + (:\s*{{startOfIdentifier}}Function{{endOfIdentifier}}) | + (:\s*{{possiblyMultilineArrow}}) + functionLikeAssignmentOrType: |- + \s* + # function assignment | + (={{functionOrArrowLookup}}) | + # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => + {{functionLikeType}} | + (:\s*(=>|{{matchingParenthesis}}|(<[^<>]*>)|[^<>(),=])+={{functionOrArrowLookup}}) + arrowFunctionEnd: (?==>|\{|(^\s*(export|function|class|interface|let|var|{{usingKeyword}}|{{awaitUsingKeyword}}|const|import|enum|namespace|module|type|abstract|declare)\s+)) + regexpTail: ([dgimsuvy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]) + completeRegexp: \/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/{{regexpTail}}) + patterns: -- include: '#expression' +- include: '#directives' +- include: '#statements' +- include: '#shebang' repository: - var-expr: - name: meta.var.expr.ts - begin: (?]|var|type|function|class|interface) + '1': { name: keyword.operator.rest.ts } + '2': { name: punctuation.definition.binding-pattern.object.ts } + end: \} + endCaptures: + '0': { name: punctuation.definition.binding-pattern.object.ts } patterns: - - include: '#type-parameters' - - include: '#type' - - name: keyword.operator.comparison.ts - match: '=\s*' + - include: '#object-binding-element-const' - enum-declaration: - name: meta.enum.declaration.ts - match: (?:\b(const)\s+)?\b(enum)\s+([a-zA-Z_$][\w$]*) - captures: - '1': { name: storage.modifier.ts} - '2': { name: storage.type.ts } - '3': { name: entity.name.class.ts } + array-binding-pattern: + begin: (?:(\.\.\.)\s*)?(\[) + beginCaptures: + '1': { name: keyword.operator.rest.ts } + '2': { name: punctuation.definition.binding-pattern.array.ts } + end: \] + endCaptures: + '0': { name: punctuation.definition.binding-pattern.array.ts } + patterns: + - include: '#binding-element' + - include: '#punctuation-comma' - object-declaration: - name: meta.declaration.object.ts - begin: '\b(?:(export)\s+)?\b(?:(abstract)\s+)?\b(? - - include: '#object-body' + - begin: (?x)(?={{propertyName}}\s*(:)) + end: (?=,|\}) + patterns: + - include: '#object-binding-element-propertyName' + - include: '#parameter-binding-element' + - include: '#paren-expression' # as fallback when coming through possibly arrow or expression scenario + - include: '#parameter-object-binding-pattern' + - include: '#destructuring-parameter-rest' + - include: '#variable-initializer' + - include: '#punctuation-comma' - object-name: - name: meta.object.name.ts - match: '[a-zA-Z_$][\w$]*' + parameter-binding-element: + patterns: + - include: '#comment' + - include: '#string' + - include: '#numeric-literal' + - include: '#regex' + - include: '#parameter-object-binding-pattern' + - include: '#parameter-array-binding-pattern' + - include: '#destructuring-parameter-rest' + - include: '#variable-initializer' + + destructuring-parameter-rest: + match: (?:(\.\.\.)\s*)?({{identifier}}) captures: - '0': { name: 'entity.name.class.ts' } + '1': { name: keyword.operator.rest.ts } + '2': { name: variable.parameter.ts } - object-heritage: - name: meta.object.heritage.ts - begin: '(?:\b(extends|implements)\b)' + parameter-object-binding-pattern: + begin: (?:(\.\.\.)\s*)?(\{) beginCaptures: - '1': { name: keyword.other.ts } - end: (?=\{) + '1': { name: keyword.operator.rest.ts } + '2': { name: punctuation.definition.binding-pattern.object.ts } + end: \} + endCaptures: + '0': { name: punctuation.definition.binding-pattern.object.ts } + patterns: + - include: '#parameter-object-binding-element' + + parameter-array-binding-pattern: + begin: (?:(\.\.\.)\s*)?(\[) + beginCaptures: + '1': { name: keyword.operator.rest.ts } + '2': { name: punctuation.definition.binding-pattern.array.ts } + end: \] endCaptures: - '1': { name: brace.curly.ts } + '0': { name: punctuation.definition.binding-pattern.array.ts } + patterns: + - include: '#parameter-binding-element' + - include: '#punctuation-comma' + + field-declaration: + name: meta.field.declaration.ts + begin: (?x)(? + - match: |- + (?x)({{propertyIdentifier}})(?:(\?)|(\!))?(?=\s*{{functionLikeAssignmentOrType}}) + captures: + '1': { name: meta.definition.property.ts entity.name.function.ts } + '2': { name: keyword.operator.optional.ts } + '3': { name: keyword.operator.definiteassignment.ts } + - name: meta.definition.property.ts variable.object.property.ts + match: '{{propertyIdentifier}}' + - name: keyword.operator.optional.ts + match: \? + - name: keyword.operator.definiteassignment.ts + match: \! + + variable-initializer: + patterns: + # if it is assignment with expression on same line, use end of line as end of scope + - begin: (?\s*$) + beginCaptures: + '1': { name: keyword.operator.assignment.ts } + end: (?=$|^|[,);}\]]|({{startOfIdentifier}}(of|in)\s+)) + patterns: + - include: '#expression' + # if the expression doesnt start on same line do not use end of line as end of unless the complete line is blank + - begin: (?) + captures: + '1': { name: storage.modifier.async.ts } + '2': { name: variable.parameter.ts } + # parenthesized arrow + - name: meta.arrow.ts + begin: >- + (?x) + (?: + {{startOfIdentifier}}(\basync) + )? + ((? + beginCaptures: + '0': { name: storage.type.function.arrow.ts } + end: ((?<=\}|\S)(?)|((?!\{)(?=\S)))(?!\/[\/\*]) + patterns: + - include: '#single-line-comment-consuming-line-ending' + - include: '#decl-block' + - include: '#expression' + + indexer-declaration: + name: meta.indexer.declaration.ts + begin: (?:{{startOfIdentifier}}(readonly)\s*)?\s*(\[)\s*({{identifier}})\s*(?=:) + beginCaptures: + '1': { name: storage.modifier.ts } + '2': { name: meta.brace.square.ts } + '3': { name: variable.parameter.ts} + end: (\])\s*(\?\s*)?|$ + endCaptures: + '1': { name: meta.brace.square.ts } + '2': { name: keyword.operator.optional.ts } + patterns: + - include: '#type-annotation' + + indexer-mapped-type-declaration: + name: meta.indexer.mappedtype.declaration.ts + begin: (?:{{startOfIdentifier}}([+-])?(readonly)\s*)?\s*(\[)\s*({{identifier}})\s+(in)\s+ + beginCaptures: + '1': { name: keyword.operator.type.modifier.ts } + '2': { name: storage.modifier.ts } + '3': { name: meta.brace.square.ts } + '4': { name: entity.name.type.ts } + '5': { name: keyword.operator.expression.in.ts } + end: (\])([+-])?\s*(\?\s*)?|$ + endCaptures: + '1': { name: meta.brace.square.ts } + '2': { name: keyword.operator.type.modifier.ts } + '3': { name: keyword.operator.optional.ts } + patterns: + - match: '{{startOfIdentifier}}(as)\s+' + captures: + '1': { name: keyword.control.as.ts } + - include: '#type' + + function-parameters: + name: meta.parameters.ts + begin: \( + beginCaptures: + '0': { name: punctuation.definition.parameters.begin.ts } + end: \) + endCaptures: + '0': { name: punctuation.definition.parameters.end.ts } + patterns: + - include: '#function-parameters-body' + + # When updating this, also update the expression-inside-possibly-arrow-parens where this is inlined so that parameter-name can also be inlined + function-parameters-body: + patterns: + - include: '#comment' + - include: '#string' + - include: '#decorator' + - include: '#destructuring-parameter' + - include: '#parameter-name' + - include: '#parameter-type-annotation' + - include: '#variable-initializer' + - name: punctuation.separator.parameter.ts + match: ',' + + #class declaration and expression, interface + class-declaration: + name: meta.class.ts + begin: '{{startOfDeclaration}}\b(?:(abstract)\s+)?\b(class)\b(?=\s+|/[/*])' + beginCaptures: + '1': { name: keyword.control.export.ts } + '2': { name: storage.modifier.ts } + '3': { name: storage.modifier.ts } + '4': { name: storage.type.class.ts } + end: (?<=\}) + patterns: + - include: '#class-declaration-or-expression-patterns' + + class-expression: + name: meta.class.ts + # allows anonymous class + begin: '{{startOfIdentifier}}(?:(abstract)\s+)?(class)\b(?=\s+|[<{]|\/[\/*])' + beginCaptures: + '1': { name: storage.modifier.ts } + '2': { name: storage.type.class.ts } + end: (?<=\}) + patterns: + - include: '#class-declaration-or-expression-patterns' - object-body: - name: meta.object.body.ts + class-declaration-or-expression-patterns: + patterns: + - include: '#comment' + - include: '#class-or-interface-heritage' # Must be before object-name to consume the "extends" keyword. + - match: '{{identifier}}' + captures: + '0': { name: 'entity.name.type.class.ts' } + - include: '#type-parameters' # Must be applied after object-name e.g. interface KeyValuePair + - include: '#class-or-interface-body' + + interface-declaration: + name: meta.interface.ts + begin: '{{startOfDeclaration}}\b(?:(abstract)\s+)?\b(interface)\b(?=\s+|/[/*])' + beginCaptures: + '1': { name: keyword.control.export.ts } + '2': { name: storage.modifier.ts } + '3': { name: storage.modifier.ts } + '4': { name: storage.type.interface.ts } + end: (?<=\}) + patterns: + - include: '#comment' + - include: '#class-or-interface-heritage' # Must be before object-name to consume the "extends" keyword. + - match: '{{identifier}}' + captures: + '0': { name: 'entity.name.type.interface.ts' } + - include: '#type-parameters' # Must be applied after object-name e.g. interface KeyValuePair + - include: '#class-or-interface-body' + + class-or-interface-heritage: + begin: '{{startOfIdentifier}}(?:\b(extends|implements)\b){{endOfIdentifier}}' + beginCaptures: + '1': { name: storage.modifier.ts } + end: (?=\{) + patterns: + - include: '#comment' + - include: '#class-or-interface-heritage' + - include: '#type-parameters' + # match expressions before matching identifiers + - include: '#expressionWithoutIdentifiers' + # identifiers are treated as inherited class + - match: '({{identifier}})\s*{{propertyAccess}}(?=\s*{{identifier}}(\s*{{propertyAccessPreIdentifier}}{{identifier}})*\s*)' + captures: + '1': { name: entity.name.type.module.ts } + '2': { name: punctuation.accessor.ts } + '3': { name: punctuation.accessor.optional.ts } + - match: ({{identifier}}) + captures: + '1': { name: entity.other.inherited-class.ts } + # match punctuations of the expression + - include: '#expressionPunctuations' + + class-or-interface-body: begin: \{ beginCaptures: - '0': { name: meta.brace.curly.ts } + '0': { name: punctuation.definition.block.ts } end: \} endCaptures: - '0': { name: meta.brace.curly.ts } + '0': { name: punctuation.definition.block.ts } patterns: - - include: "#string" - include: '#comment' - - include: '#field-declaration' + - include: '#decorator' + # The : could most probably be end of ternary expression so to avoid matching expression following it as field declaration, explicitly match it as expression + - begin: (?<=:)\s* + end: (?=\s|[;),}\]:\-\+]|{{endOfStatement}}) + patterns: + - include: '#expression' - include: '#method-declaration' - include: '#indexer-declaration' + - include: '#field-declaration' + - include: "#string" - include: '#type-annotation' - include: '#variable-initializer' - include: '#access-modifier' - - include: '#static-modifier' - include: '#property-accessor' + - include: '#async-modifier' + - include: '#after-operator-block-as-object-literal' + - include: '#decl-block' + - include: '#expression' + - include: '#punctuation-comma' + - include: '#punctuation-semicolon' - type-object: - name: meta.object.type.ts + access-modifier: + name: storage.modifier.ts + match: '{{startOfIdentifier}}(abstract|declare|override|public|protected|private|readonly|static){{endOfIdentifier}}' + + property-accessor: + name: storage.type.property.ts + match: '{{startOfIdentifier}}(accessor|get|set){{endOfIdentifier}}' + + async-modifier: + name: storage.modifier.async.ts + match: '{{startOfIdentifier}}(async){{endOfIdentifier}}' + + #enum + enum-declaration: + name: meta.enum.declaration.ts + begin: '{{startOfDeclaration}}(?:\b(const)\s+)?\b(enum)\s+({{identifier}})' + beginCaptures: + '1': { name: keyword.control.export.ts } + '2': { name: storage.modifier.ts} + '3': { name: storage.modifier.ts} + '4': { name: storage.type.enum.ts } + '5': { name: entity.name.type.enum.ts } + end: (?<=\}) + patterns: + - include: '#comment' + - begin: \{ + beginCaptures: + '0': { name: punctuation.definition.block.ts } + end: \} + endCaptures: + '0': { name: punctuation.definition.block.ts } + patterns: + - include: '#comment' + - begin: ({{identifier}}) + beginCaptures: + '0': { name: variable.other.enummember.ts } + end: (?=,|\}|$) + patterns: + - include: '#comment' + - include: '#variable-initializer' + - begin: (?=({{nonIdentifierPropertyName}})) + end: (?=,|\}|$) + patterns: + - include: '#string' + - include: '#array-literal' + - include: '#comment' + - include: '#variable-initializer' + - include: '#punctuation-comma' + + #namespace + namespace-declaration: + name: meta.namespace.declaration.ts + begin: (?:{{startOfDeclaration}}\b(namespace|module)\s+(?=[_$[:alpha:]"'`])) + beginCaptures: + '1': { name: keyword.control.export.ts } + '2': { name: storage.modifier.ts } + '3': { name: storage.type.namespace.ts } + end: (?<=\})|(?={{endOfStatement}}) + patterns: + - include: '#comment' + - include: '#string' + - name: entity.name.type.module.ts + match: ({{identifier}}) + - include: '#punctuation-accessor' + - include: '#decl-block' + + #type alias + type-alias-declaration: + name: meta.type.declaration.ts + begin: '{{startOfDeclaration}}\b(type)\b\s+({{identifier}})\s*' + beginCaptures: + '1': { name: keyword.control.export.ts } + '2': { name: storage.modifier.ts } + '3': { name: storage.type.type.ts } + '4': { name: entity.name.type.alias.ts } + end: (?=\}|{{endOfStatement}}) + patterns: + - include: '#comment' + - include: '#type-parameters' + - begin: '(=)\s*(intrinsic){{endOfIdentifier}}' + beginCaptures: + '1': { name: keyword.operator.assignment.ts } + '2': { name: keyword.control.intrinsic.ts } + end: (?=\}|{{endOfStatement}}) + patterns: + - include: '#type' + - begin: '(=)\s*' + beginCaptures: + '1': { name: keyword.operator.assignment.ts } + end: (?=\}|{{endOfStatement}}) + patterns: + - include: '#type' + + #import and export + import-equals-declaration: + patterns: + - name: meta.import-equals.external.ts + begin: '{{startOfDeclaration}}\b(import)(?:\s+(type))?\s+({{identifier}})\s*(=)\s*(require)\s*(\()' + beginCaptures: + '1': { name: keyword.control.export.ts } + '2': { name: storage.modifier.ts } + '3': { name: keyword.control.import.ts } + '4': { name: keyword.control.type.ts } + '5': { name: variable.other.readwrite.alias.ts } + '6': { name: keyword.operator.assignment.ts } + '7': { name: keyword.control.require.ts } + '8': { name: meta.brace.round.ts } + end: \) + endCaptures: + '0': { name: meta.brace.round.ts } + patterns: + - include: '#comment' + - include: '#string' + - name: meta.import-equals.internal.ts + begin: '{{startOfDeclaration}}\b(import)(?:\s+(type))?\s+({{identifier}})\s*(=)\s*(?!require\b)' + beginCaptures: + '1': { name: keyword.control.export.ts } + '2': { name: storage.modifier.ts } + '3': { name: keyword.control.import.ts } + '4': { name: keyword.control.type.ts } + '5': { name: variable.other.readwrite.alias.ts } + '6': { name: keyword.operator.assignment.ts } + end: (?=;|$|^) + patterns: + - include: '#single-line-comment-consuming-line-ending' + - include: '#comment' + - match: ({{identifier}})\s*{{propertyAccess}} + captures: + '1': { name: entity.name.type.module.ts } + '2': { name: punctuation.accessor.ts } + '3': { name: punctuation.accessor.optional.ts } + - name: variable.other.readwrite.ts + match: ({{identifier}}) + + import-declaration: + name: meta.import.ts + begin: '{{startOfDeclaration}}\b(import)(?:\s+(type)(?!\s+from))?(?!\s*[:\(]){{endOfIdentifier}}' + beginCaptures: + '1': { name: keyword.control.export.ts } + '2': { name: storage.modifier.ts } + '3': { name: keyword.control.import.ts } + '4': { name: keyword.control.type.ts } + end: (?]|{{lookBehindAwait}}|{{lookBehindReturn}}|{{lookBehindYield}}|{{lookBehindThrow}}|{{lookBehindIn}}|{{lookBehindOf}}|{{lookBehindTypeof}}|&&|\|\||\*)\s*(\{) + beginCaptures: + '1': { name: punctuation.definition.block.ts } + end: \} + endCaptures: + '0': { name: punctuation.definition.block.ts } + patterns: + - include: '#object-member' + + object-literal: + name: meta.objectliteral.ts + begin: \{ + beginCaptures: + '0': { name: punctuation.definition.block.ts } + end: \} + endCaptures: + '0': { name: punctuation.definition.block.ts } + patterns: + - include: '#object-member' + + object-member: + patterns: + - include: '#comment' + - include: '#object-literal-method-declaration' + - name: meta.object.member.ts meta.object-literal.key.ts + begin: (?=\[) + end: (?=:)|((?<=[\]])(?=\s*[\(\<])) + patterns: + - include: '#comment' + - include: '#array-literal' + - name: meta.object.member.ts meta.object-literal.key.ts + begin: (?=[\'\"\`]) + end: (?=:)|((?<=[\'\"\`])(?=((\s*[\(\<,}])|(\s+(as|satisifies)\s+)))) + patterns: + - include: '#comment' + - include: '#string' + - name: meta.object.member.ts meta.object-literal.key.ts + begin: (?x)(?={{anyNumber}}) + end: (?=:)|(?=\s*([\(\<,}])|(\s+as|satisifies\s+)) + patterns: + - include: '#comment' + - include: '#numeric-literal' + - name: meta.method.declaration.ts + begin: (?<=[\]\'\"\`])(?=\s*[\(\<]) + end: (?=\}|;|,)|(?<=\}) + patterns: + - include: '#function-body' + - name: meta.object.member.ts + match: (?![_$[:alpha:]])([[:digit:]]+)\s*(?=({{inlineComment}}\s*)*:) + captures: + '0': { name: meta.object-literal.key.ts } + '1': { name: constant.numeric.decimal.ts } + - name: meta.object.member.ts + match: |- + (?x)(?:({{identifier}})\s*(?=({{inlineComment}}\s*)*:(\s*{{inlineComment}})*{{functionOrArrowLookup}})) + captures: + '0': { name: meta.object-literal.key.ts } + '1': { name: entity.name.function.ts } + - name: meta.object.member.ts + match: (?:{{identifier}})\s*(?=({{inlineComment}}\s*)*:) + captures: + '0': { name: meta.object-literal.key.ts } + - name: meta.object.member.ts + begin: \.\.\. + beginCaptures: + '0': { name: keyword.operator.spread.ts } + end: (?=,|\}) + patterns: + - include: '#expression' + - name: meta.object.member.ts + match: ({{identifier}})\s*(?=,|\}|$|\/\/|\/\*) + captures: + '1': { name: variable.other.readwrite.ts } + - name: meta.object.member.ts + match: '{{startOfIdentifier}}(as)\s+(const)(?=\s*([,}]|$))' + captures: + '1': { name: keyword.control.as.ts } + '2': { name: storage.modifier.ts } + - name: meta.object.member.ts + begin: '{{startOfIdentifier}}(?:(as)|(satisfies))\s+' + beginCaptures: + '1': { name: keyword.control.as.ts } + '2': { name: keyword.control.satisfies.ts } + end: (?={{lookAheadEndOfType}}|^|({{startOfIdentifier}}(as|satisifies)\s+)) + patterns: + - include: '#type' + - name: meta.object.member.ts + begin: (?={{identifier}}\s*=) + end: (?=,|\}|$|\/\/|\/\*) + patterns: + - include: '#expression' + # object member body: + - name: meta.object.member.ts + begin: ':' + beginCaptures: + '0': { name: meta.object-literal.key.ts punctuation.separator.key-value.ts } + end: (?=,|\}) + patterns: + - begin: '{{lookBehindOfObjectMemberPossiblyMultilineArrow}}\s*(async)?(?=\s*{{typeParameters}}\(\s*{{possiblyMultilineArrowWParamters}})' + beginCaptures: + '1': { name: storage.modifier.async.ts } + end: (?<=\)) + patterns: + - include: '#type-parameters' + - begin: \( + beginCaptures: + '0': { name: meta.brace.round.ts } + end: \) + endCaptures: + '0': { name: meta.brace.round.ts } + patterns: + - include: '#expression-inside-possibly-arrow-parens' + - begin: '{{lookBehindOfObjectMemberPossiblyMultilineArrow}}\s*(async)?\s*(\()(?=\s*{{possiblyMultilineArrowWParamters}})' + beginCaptures: + '1': { name: storage.modifier.async.ts } + '2': { name: meta.brace.round.ts } + end: \) + endCaptures: + '0': { name: meta.brace.round.ts } + patterns: + - include: '#expression-inside-possibly-arrow-parens' + - begin: '{{lookBehindOfObjectMemberPossiblyMultilineArrow}}\s*(async)?\s*(?=\<\s*$)' + beginCaptures: + '1': { name: storage.modifier.async.ts } + end: (?<=\>) + patterns: + - include: '#type-parameters' + - begin: '(?<=\>)\s*(\()(?=\s*{{possiblyMultilineArrowWParamters}})' + beginCaptures: + '1': { name: meta.brace.round.ts } + end: \) + endCaptures: + '0': { name: meta.brace.round.ts } + patterns: + - include: '#expression-inside-possibly-arrow-parens' + - include: '#possibly-arrow-return-type' + - include: '#expression' + - include: '#punctuation-comma' + - include: '#decl-block' + + #ternary expression + ternary-expression: + begin: (?!\?\.\s*[^[:digit:]])(\?)(?!\?) + beginCaptures: + '1': { name: keyword.operator.ternary.ts } + end: \s*(:) + endCaptures: + '1': { name: keyword.operator.ternary.ts } + patterns: + - include: '#expression' + + #function call and new expression + function-call: + patterns: + - begin: (?={{functionCallTarget}}{{functionCallLookup}}) + end: (?<=\))(?!{{functionCallTarget}}{{functionCallLookup}}) + patterns: + - name: meta.function-call.ts + begin: (?={{functionCallNamedTarget}}) + end: (?={{functionCallLookup}}) + patterns: + - include: '#function-call-target' + - include: '#comment' + - include: '#function-call-optionals' + - include: '#type-arguments' + - include: '#paren-expression' + - begin: (?={{functionCallTarget}}{{possiblyMultilineTypeArgument}}) + end: (?<=\>)(?!{{functionCallTarget}}{{possiblyMultilineTypeArgument}}) + patterns: + - name: meta.function-call.ts + begin: (?={{functionCallNamedTarget}}) + end: (?={{possiblyMultilineTypeArgument}}) + patterns: + - include: '#function-call-target' + - include: '#comment' + - include: '#function-call-optionals' + - include: '#type-arguments' + + function-call-target: + patterns: + - include: '#support-function-call-identifiers' + - name: entity.name.function.ts + match: ({{propertyIdentifier}}) + + function-call-optionals: + patterns: + - name: meta.function-call.ts punctuation.accessor.optional.ts + match: \?\. + - name: meta.function-call.ts keyword.operator.definiteassignment.ts + match: \! + + support-function-call-identifiers: + patterns: + - include: '#literal' + - include: '#support-objects' + - include: '#object-identifiers' + - include: '#punctuation-accessor' + - name: keyword.operator.expression.import.ts + match: (?:{{startOfIdentifier}}import(?=\s*[\(]\s*[\"\'\`])) + + new-expr: + name: new.expr.ts + begin: '{{startOfIdentifier}}(new){{endOfIdentifier}}' + beginCaptures: + '1': { name: keyword.operator.new.ts } + end: (?<=\))|(?={{lookAheadEndOfType}}|({{startOfIdentifier}}new{{endOfIdentifier}})|({{startOfIdentifier}}function((\s+{{identifier}})|(\s*[\(])))) + patterns: + - include: '#expression' + + instanceof-expr: + begin: '{{startOfIdentifier}}(instanceof){{endOfIdentifier}}' + beginCaptures: + '1': { name: keyword.operator.expression.instanceof.ts } + end: (?<=\))|(?={{lookAheadEndOfType}}|(===|!==|==|!=)|(([\&\~\^\|]\s*)?{{identifier}}\s+instanceof{{endOfIdentifier}})|({{startOfIdentifier}}function((\s+{{identifier}})|(\s*[\(])))) + patterns: + - include: '#type' + + # when ( is followed by end of line, it could be arrow parameter decarations, so inside this match as if parameter falling back to expression + # but do this only from expression and as last resort + paren-expression-possibly-arrow: + patterns: + - begin: '{{lookBehindOfPossiblyMultilineArrowWithDestructuring}}\s*(async)?(?=\s*({{typeParameters}})?\(\s*{{possiblyMultilineArrowWParamters}})' + beginCaptures: + '1': { name: storage.modifier.async.ts } + end: (?<=\)) + patterns: + - include: '#paren-expression-possibly-arrow-with-typeparameters' + - begin: '{{lookBehindOfPossiblyMultilineArrow}}\s*(async)?(?=\s*{{possiblyMultilineArrowExpressionBeforeEndOfLine}}\s*$)' + beginCaptures: + '1': { name: storage.modifier.async.ts } + end: (?<=\)) + patterns: + - include: '#paren-expression-possibly-arrow-with-typeparameters' + - include: '#possibly-arrow-return-type' + + paren-expression-possibly-arrow-with-typeparameters: + patterns: + - include: '#type-parameters' + - begin: \( + beginCaptures: + '0': { name: meta.brace.round.ts } + end: \) + endCaptures: + '0': { name: meta.brace.round.ts } + patterns: + - include: '#expression-inside-possibly-arrow-parens' + + expression-inside-possibly-arrow-parens: + patterns: + - include: '#expressionWithoutIdentifiers' + - include: '#comment' + - include: '#string' + - include: '#decorator' + - include: '#destructuring-parameter' + - match: '{{startOfIdentifier}}(override|public|protected|private|readonly)\s+(?=(override|public|protected|private|readonly)\s+)' + captures: + '1': { name: storage.modifier.ts } + - match: |- + (?x)(?:{{startOfIdentifier}}(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?) + captures: + '1': { name: meta.brace.angle.ts } + '2': { name: storage.modifier.ts } + '3': { name: meta.brace.angle.ts } + - name: cast.expr.ts + # We need to differentiate between the relational '<' operator and the beginning of a type assertion/cast using the surrounding context. + # If '<' is preceeded by 'return', 'throw', 'yield', or 'await', it's most likely a type assertion + # If '=', '(', ',', ':', or '>' are followed by a '<', it is also likely a type assertion as otherwise it would be a syntax error + # '<=' and '<<=' are cannot be type assertions, as they are assignment operators. + begin: (?:(?*?\&\|\^]|[^_$[:alnum:]](?:\+\+|\-\-)|[^\+]\+|[^\-]\-))\s*(<)(?!) + endCaptures: + '1': { name: meta.brace.angle.ts } + patterns: + - include: '#type' + - name: cast.expr.ts + # Specialize the pattern that is allowed at the beginning of the new line to treat as cast + # < appears on new line allow only as type assertion + # This allows treating '<' on new line as relation operator in other cases. + # People writing one operator on new line and second one on same line should be rare to allow this. + begin: (?:(?<=^))\s*(<)(?={{identifier}}\s*>) + beginCaptures: + '1': { name: meta.brace.angle.ts } + end: (\>) + endCaptures: + '1': { name: meta.brace.angle.ts } + patterns: + - include: '#type' + + #expression operators + expression-operators: + patterns: + - name: keyword.control.flow.ts + match: '{{startOfIdentifier}}(await){{endOfIdentifier}}' + - begin: '{{startOfIdentifier}}(yield){{endOfIdentifier}}(?=\s*{{inlineComment}}\s*\*)' + beginCaptures: + '1': { name: keyword.control.flow.ts } + end: \* + endCaptures: + '0': { name: keyword.generator.asterisk.ts } + patterns: + - include: '#comment' + - match: '{{startOfIdentifier}}(yield){{endOfIdentifier}}(?:\s*(\*))?' + captures: + '1': { name: keyword.control.flow.ts } + '2': { name: keyword.generator.asterisk.ts } + - name: keyword.operator.expression.delete.ts + match: '{{startOfIdentifier}}delete{{endOfIdentifier}}' + - name: keyword.operator.expression.in.ts + match: '{{startOfIdentifier}}in{{endOfIdentifier}}(?!\()' + - name: keyword.operator.expression.of.ts + match: '{{startOfIdentifier}}of{{endOfIdentifier}}(?!\()' + - name: keyword.operator.expression.instanceof.ts + match: '{{startOfIdentifier}}instanceof{{endOfIdentifier}}' + - name: keyword.operator.new.ts + match: '{{startOfIdentifier}}new{{endOfIdentifier}}' + - include: '#typeof-operator' + - name: keyword.operator.expression.void.ts + match: '{{startOfIdentifier}}void{{endOfIdentifier}}' + #handle as operator specifically to be recognized only if it is 'as' followed by space + - match: '{{startOfIdentifier}}(as)\s+(const)(?=\s*($|[;,:})\]]))' + captures: + '1': { name: keyword.control.as.ts } + '2': { name: storage.modifier.ts } + - begin: '{{startOfIdentifier}}(?:(as)|(satisfies))\s+' + beginCaptures: + '1': { name: keyword.control.as.ts } + '2': { name: keyword.control.satisfies.ts } + end: (?=^|{{lookAheadEndOfType}}|({{startOfIdentifier}}(as|satisfies)\s+)|(\s+\<)) + patterns: + - include: '#type' + - name: keyword.operator.spread.ts + match: \.\.\. + - name: keyword.operator.assignment.compound.ts + match: \*=|(?>=|>>>=|\|= + - name: keyword.operator.bitwise.shift.ts + match: <<|>>>|>> + - name: keyword.operator.comparison.ts + match: ===|!==|==|!= + - name: keyword.operator.relational.ts + match: <=|>=|<>|<|> + - match: (?<=[_$[:alnum:]])(\!)\s*(?:(/=)|(?:(/)(?![/*]))) + captures: + '1': { name: keyword.operator.logical.ts } + '2': { name: keyword.operator.assignment.compound.ts } + '3': { name: keyword.operator.arithmetic.ts } + - name: keyword.operator.logical.ts + match: \!|&&|\|\||\?\? + - name: keyword.operator.bitwise.ts + match: \&|~|\^|\| + - name: keyword.operator.assignment.ts + match: \= + - name: keyword.operator.decrement.ts + match: -- + - name: keyword.operator.increment.ts + match: \+\+ + - name: keyword.operator.arithmetic.ts + match: '%|\*|/|-|\+' + # capture the arithmetic sign followed by variable or parenthesized expression so that it is not interpreted as regex + - begin: (?<=[_$[:alnum:])\]])\s*(?=({{inlineComment}}\s*)+(?:(/=)|(?:(/)(?![/*])))) + end: (?:(/=)|(?:(/)(?!\*([^\*]|(\*[^\/]))*\*\/))) + endCaptures: + '1': { name: keyword.operator.assignment.compound.ts } + '2': { name: keyword.operator.arithmetic.ts } + patterns: + - include: '#comment' + - match: (?<=[_$[:alnum:])\]])\s*(?:(/=)|(?:(/)(?![/*]))) + captures: + '1': { name: keyword.operator.assignment.compound.ts } + '2': { name: keyword.operator.arithmetic.ts } + + typeof-operator: + begin: '{{startOfIdentifier}}typeof{{endOfIdentifier}}' + beginCaptures: + '0': { name: keyword.operator.expression.typeof.ts } + end: (?=[,);}\]=>:&|{\?]|(extends\s+)|$|{{endOfStatement}}) + patterns: + - include: '#type-arguments' + - include: '#expression' + + #literals + literal: + patterns: + - include: '#numeric-literal' + - include: '#boolean-literal' + - include: '#null-literal' + - include: '#undefined-literal' + - include: '#numericConstant-literal' + - include: '#array-literal' + - include: '#this-literal' + - include: '#super-literal' + + array-literal: + name: meta.array.literal.ts + begin: \s*(\[) + beginCaptures: + '1': { name: meta.brace.square.ts } + end: \] + endCaptures: + '0': { name: meta.brace.square.ts } + patterns: + - include: '#expression' + - include: '#punctuation-comma' + + # With respect to seperators, we allow mroe than is syntacically valid below + # (multiple consecutive and trailing ones are errors), to be more graceful + # when the code contains errors + numeric-literal: + patterns: + - name: constant.numeric.hex.ts + match: '{{hexNumber}}' + captures: + '1': { name: storage.type.numeric.bigint.ts } + - name: constant.numeric.binary.ts + match: '{{binaryNumber}}' + captures: + '1': { name: storage.type.numeric.bigint.ts } + - name: constant.numeric.octal.ts + match: '{{octalNumber}}' + captures: + '1': { name: storage.type.numeric.bigint.ts } + - match: |- + (?x) + {{decimalNumber}} + captures: + '0': {name: constant.numeric.decimal.ts} + '1': {name: meta.delimiter.decimal.period.ts} + '2': { name: storage.type.numeric.bigint.ts } + '3': {name: meta.delimiter.decimal.period.ts} + '4': { name: storage.type.numeric.bigint.ts } + '5': {name: meta.delimiter.decimal.period.ts} + '6': { name: storage.type.numeric.bigint.ts } + '7': { name: storage.type.numeric.bigint.ts } + '8': {name: meta.delimiter.decimal.period.ts} + '9': { name: storage.type.numeric.bigint.ts } + '10': {name: meta.delimiter.decimal.period.ts} + '11': { name: storage.type.numeric.bigint.ts } + '12': {name: meta.delimiter.decimal.period.ts} + '13': { name: storage.type.numeric.bigint.ts } + '14': { name: storage.type.numeric.bigint.ts } + + boolean-literal: + patterns: + - name: constant.language.boolean.true.ts + match: '{{startOfIdentifier}}true{{endOfIdentifier}}' + - name: constant.language.boolean.false.ts + match: '{{startOfIdentifier}}false{{endOfIdentifier}}' + + null-literal: + name: constant.language.null.ts + match: '{{startOfIdentifier}}null{{endOfIdentifier}}' + + this-literal: + name: variable.language.this.ts + match: '{{startOfIdentifier}}this\b(?!\$)' + + super-literal: + name: variable.language.super.ts + match: '{{startOfIdentifier}}super\b(?!\$)' + + undefined-literal: + name: constant.language.undefined.ts + match: '{{startOfIdentifier}}undefined{{endOfIdentifier}}' + + numericConstant-literal: + patterns: + - name: constant.language.nan.ts + match: '{{startOfIdentifier}}NaN{{endOfIdentifier}}' + - name: constant.language.infinity.ts + match: '{{startOfIdentifier}}Infinity{{endOfIdentifier}}' + + #identifiers, support variables + support-objects: + patterns: + - name: variable.language.arguments.ts + match: '{{startOfIdentifier}}(arguments)\b(?!\$)' + # builtins + - name: support.class.builtin.ts + match: |- + (?x){{startOfIdentifier}}(Array|ArrayBuffer|Atomics|BigInt|BigInt64Array|BigUint64Array|Boolean|DataView|Date|Float32Array + |Float64Array|Function|Generator|GeneratorFunction|Int8Array|Int16Array|Int32Array|Intl|Map|Number|Object|Proxy + |Reflect|RegExp|Set|SharedArrayBuffer|SIMD|String|Symbol|TypedArray + |Uint8Array|Uint16Array|Uint32Array|Uint8ClampedArray|WeakMap|WeakSet)\b(?!\$) + - name: support.class.error.ts + match: '{{startOfIdentifier}}((Eval|Internal|Range|Reference|Syntax|Type|URI)?Error)\b(?!\$)' + - name: support.class.promise.ts + match: '{{startOfIdentifier}}(Promise)\b(?!\$)' + # known builtin function calls + - name: support.function.ts + match: |- + (?x){{startOfIdentifier}}(clear(Interval|Timeout)|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval| + isFinite|isNaN|parseFloat|parseInt|require|set(Interval|Timeout)|super|unescape|uneval)(?=\s*\() + # Math + - match: |- + (?x){{startOfIdentifier}}(Math)(?:\s*{{propertyAccess}}\s*(?: + (abs|acos|acosh|asin|asinh|atan|atan2|atanh|cbrt|ceil|clz32|cos|cosh|exp| + expm1|floor|fround|hypot|imul|log|log10|log1p|log2|max|min|pow|random| + round|sign|sin|sinh|sqrt|tan|tanh|trunc) + | + (E|LN10|LN2|LOG10E|LOG2E|PI|SQRT1_2|SQRT2)))?\b(?!\$) + captures: + '1': { name: support.constant.math.ts } + '2': { name: punctuation.accessor.ts } + '3': { name: punctuation.accessor.optional.ts } + '4': { name: support.function.math.ts } + '5': { name: support.constant.property.math.ts } + # console + - match: |- + (?x){{startOfIdentifier}}(console)(?:\s*{{propertyAccess}}\s*( + assert|clear|count|debug|dir|error|group|groupCollapsed|groupEnd|info|log + |profile|profileEnd|table|time|timeEnd|timeStamp|trace|warn))?\b(?!\$) + captures: + '1': { name: support.class.console.ts } + '2': { name: punctuation.accessor.ts } + '3': { name: punctuation.accessor.optional.ts } + '4': { name: support.function.console.ts } + # JSON + - match: '{{startOfIdentifier}}(JSON)(?:\s*{{propertyAccess}}\s*(parse|stringify))?\b(?!\$)' + captures: + '1': { name: support.constant.json.ts } + '2': { name: punctuation.accessor.ts } + '3': { name: punctuation.accessor.optional.ts } + '4': { name: support.function.json.ts } + # import meta + - match: '{{startOfIdentifier}}(import)\s*{{propertyAccess}}\s*(meta)\b(?!\$)' + captures: + '1': { name: keyword.control.import.ts } + '2': { name: punctuation.accessor.ts } + '3': { name: punctuation.accessor.optional.ts } + '4': { name: support.variable.property.importmeta.ts } + # new target + - match: '{{startOfIdentifier}}(new)\s*{{propertyAccess}}\s*(target)\b(?!\$)' + captures: + '1': { name: keyword.operator.new.ts } + '2': { name: punctuation.accessor.ts } + '3': { name: punctuation.accessor.optional.ts } + '4': { name: support.variable.property.target.ts } + # DOM + - match: |- + (?x) {{propertyAccess}} \s* (?: + (?:(constructor|length|prototype|__proto__)\b(?!\$|\s*{{typeParameters}}?\()) + | + (?:(EPSILON|MAX_SAFE_INTEGER|MAX_VALUE|MIN_SAFE_INTEGER|MIN_VALUE|NEGATIVE_INFINITY|POSITIVE_INFINITY)\b(?!\$))) + captures: + '1': { name: punctuation.accessor.ts } + '2': { name: punctuation.accessor.optional.ts } + '3': { name: support.variable.property.ts } + '4': { name: support.constant.ts } + - match: |- + (?x) {{startOfIdentifier}} \b (?: + (document|event|navigator|performance|screen|window) + | + (AnalyserNode|ArrayBufferView|Attr|AudioBuffer|AudioBufferSourceNode|AudioContext|AudioDestinationNode|AudioListener + |AudioNode|AudioParam|BatteryManager|BeforeUnloadEvent|BiquadFilterNode|Blob|BufferSource|ByteString|CSS|CSSConditionRule + |CSSCounterStyleRule|CSSGroupingRule|CSSMatrix|CSSMediaRule|CSSPageRule|CSSPrimitiveValue|CSSRule|CSSRuleList|CSSStyleDeclaration + |CSSStyleRule|CSSStyleSheet|CSSSupportsRule|CSSValue|CSSValueList|CanvasGradient|CanvasImageSource|CanvasPattern + |CanvasRenderingContext2D|ChannelMergerNode|ChannelSplitterNode|CharacterData|ChromeWorker|CloseEvent|Comment|CompositionEvent + |Console|ConvolverNode|Coordinates|Credential|CredentialsContainer|Crypto|CryptoKey|CustomEvent|DOMError|DOMException + |DOMHighResTimeStamp|DOMImplementation|DOMString|DOMStringList|DOMStringMap|DOMTimeStamp|DOMTokenList|DataTransfer + |DataTransferItem|DataTransferItemList|DedicatedWorkerGlobalScope|DelayNode|DeviceProximityEvent|DirectoryEntry + |DirectoryEntrySync|DirectoryReader|DirectoryReaderSync|Document|DocumentFragment|DocumentTouch|DocumentType|DragEvent + |DynamicsCompressorNode|Element|Entry|EntrySync|ErrorEvent|Event|EventListener|EventSource|EventTarget|FederatedCredential + |FetchEvent|File|FileEntry|FileEntrySync|FileException|FileList|FileReader|FileReaderSync|FileSystem|FileSystemSync + |FontFace|FormData|GainNode|Gamepad|GamepadButton|GamepadEvent|Geolocation|GlobalEventHandlers|HTMLAnchorElement + |HTMLAreaElement|HTMLAudioElement|HTMLBRElement|HTMLBaseElement|HTMLBodyElement|HTMLButtonElement|HTMLCanvasElement + |HTMLCollection|HTMLContentElement|HTMLDListElement|HTMLDataElement|HTMLDataListElement|HTMLDialogElement|HTMLDivElement + |HTMLDocument|HTMLElement|HTMLEmbedElement|HTMLFieldSetElement|HTMLFontElement|HTMLFormControlsCollection|HTMLFormElement + |HTMLHRElement|HTMLHeadElement|HTMLHeadingElement|HTMLHtmlElement|HTMLIFrameElement|HTMLImageElement|HTMLInputElement + |HTMLKeygenElement|HTMLLIElement|HTMLLabelElement|HTMLLegendElement|HTMLLinkElement|HTMLMapElement|HTMLMediaElement + |HTMLMetaElement|HTMLMeterElement|HTMLModElement|HTMLOListElement|HTMLObjectElement|HTMLOptGroupElement|HTMLOptionElement + |HTMLOptionsCollection|HTMLOutputElement|HTMLParagraphElement|HTMLParamElement|HTMLPreElement|HTMLProgressElement + |HTMLQuoteElement|HTMLScriptElement|HTMLSelectElement|HTMLShadowElement|HTMLSourceElement|HTMLSpanElement|HTMLStyleElement + |HTMLTableCaptionElement|HTMLTableCellElement|HTMLTableColElement|HTMLTableDataCellElement|HTMLTableElement|HTMLTableHeaderCellElement + |HTMLTableRowElement|HTMLTableSectionElement|HTMLTextAreaElement|HTMLTimeElement|HTMLTitleElement|HTMLTrackElement + |HTMLUListElement|HTMLUnknownElement|HTMLVideoElement|HashChangeEvent|History|IDBCursor|IDBCursorWithValue|IDBDatabase + |IDBEnvironment|IDBFactory|IDBIndex|IDBKeyRange|IDBMutableFile|IDBObjectStore|IDBOpenDBRequest|IDBRequest|IDBTransaction + |IDBVersionChangeEvent|IIRFilterNode|IdentityManager|ImageBitmap|ImageBitmapFactories|ImageData|Index|InputDeviceCapabilities + |InputEvent|InstallEvent|InstallTrigger|KeyboardEvent|LinkStyle|LocalFileSystem|LocalFileSystemSync|Location|MIDIAccess + |MIDIConnectionEvent|MIDIInput|MIDIInputMap|MIDIOutputMap|MediaElementAudioSourceNode|MediaError|MediaKeyMessageEvent + |MediaKeySession|MediaKeyStatusMap|MediaKeySystemAccess|MediaKeySystemConfiguration|MediaKeys|MediaRecorder|MediaStream + |MediaStreamAudioDestinationNode|MediaStreamAudioSourceNode|MessageChannel|MessageEvent|MessagePort|MouseEvent + |MutationObserver|MutationRecord|NamedNodeMap|Navigator|NavigatorConcurrentHardware|NavigatorGeolocation|NavigatorID + |NavigatorLanguage|NavigatorOnLine|Node|NodeFilter|NodeIterator|NodeList|NonDocumentTypeChildNode|Notification + |OfflineAudioCompletionEvent|OfflineAudioContext|OscillatorNode|PageTransitionEvent|PannerNode|ParentNode|PasswordCredential + |Path2D|PaymentAddress|PaymentRequest|PaymentResponse|Performance|PerformanceEntry|PerformanceFrameTiming|PerformanceMark + |PerformanceMeasure|PerformanceNavigation|PerformanceNavigationTiming|PerformanceObserver|PerformanceObserverEntryList + |PerformanceResourceTiming|PerformanceTiming|PeriodicSyncEvent|PeriodicWave|Plugin|Point|PointerEvent|PopStateEvent + |PortCollection|Position|PositionError|PositionOptions|PresentationConnectionClosedEvent|PresentationConnectionList + |PresentationReceiver|ProcessingInstruction|ProgressEvent|PromiseRejectionEvent|PushEvent|PushRegistrationManager + |RTCCertificate|RTCConfiguration|RTCPeerConnection|RTCSessionDescriptionCallback|RTCStatsReport|RadioNodeList|RandomSource + |Range|ReadableByteStream|RenderingContext|SVGAElement|SVGAngle|SVGAnimateColorElement|SVGAnimateElement|SVGAnimateMotionElement + |SVGAnimateTransformElement|SVGAnimatedAngle|SVGAnimatedBoolean|SVGAnimatedEnumeration|SVGAnimatedInteger|SVGAnimatedLength + |SVGAnimatedLengthList|SVGAnimatedNumber|SVGAnimatedNumberList|SVGAnimatedPoints|SVGAnimatedPreserveAspectRatio + |SVGAnimatedRect|SVGAnimatedString|SVGAnimatedTransformList|SVGAnimationElement|SVGCircleElement|SVGClipPathElement + |SVGCursorElement|SVGDefsElement|SVGDescElement|SVGElement|SVGEllipseElement|SVGEvent|SVGFilterElement|SVGFontElement + |SVGFontFaceElement|SVGFontFaceFormatElement|SVGFontFaceNameElement|SVGFontFaceSrcElement|SVGFontFaceUriElement + |SVGForeignObjectElement|SVGGElement|SVGGlyphElement|SVGGradientElement|SVGHKernElement|SVGImageElement|SVGLength + |SVGLengthList|SVGLineElement|SVGLinearGradientElement|SVGMPathElement|SVGMaskElement|SVGMatrix|SVGMissingGlyphElement + |SVGNumber|SVGNumberList|SVGPathElement|SVGPatternElement|SVGPoint|SVGPolygonElement|SVGPolylineElement|SVGPreserveAspectRatio + |SVGRadialGradientElement|SVGRect|SVGRectElement|SVGSVGElement|SVGScriptElement|SVGSetElement|SVGStopElement|SVGStringList + |SVGStylable|SVGStyleElement|SVGSwitchElement|SVGSymbolElement|SVGTRefElement|SVGTSpanElement|SVGTests|SVGTextElement + |SVGTextPositioningElement|SVGTitleElement|SVGTransform|SVGTransformList|SVGTransformable|SVGUseElement|SVGVKernElement + |SVGViewElement|ServiceWorker|ServiceWorkerContainer|ServiceWorkerGlobalScope|ServiceWorkerRegistration|ServiceWorkerState + |ShadowRoot|SharedWorker|SharedWorkerGlobalScope|SourceBufferList|StereoPannerNode|Storage|StorageEvent|StyleSheet + |StyleSheetList|SubtleCrypto|SyncEvent|Text|TextMetrics|TimeEvent|TimeRanges|Touch|TouchEvent|TouchList|Transferable + |TreeWalker|UIEvent|USVString|VRDisplayCapabilities|ValidityState|WaveShaperNode|WebGL|WebGLActiveInfo|WebGLBuffer + |WebGLContextEvent|WebGLFramebuffer|WebGLProgram|WebGLRenderbuffer|WebGLRenderingContext|WebGLShader|WebGLShaderPrecisionFormat + |WebGLTexture|WebGLTimerQueryEXT|WebGLTransformFeedback|WebGLUniformLocation|WebGLVertexArrayObject|WebGLVertexArrayObjectOES + |WebSocket|WebSockets|WebVTT|WheelEvent|Window|WindowBase64|WindowEventHandlers|WindowTimers|Worker|WorkerGlobalScope + |WorkerLocation|WorkerNavigator|XMLHttpRequest|XMLHttpRequestEventTarget|XMLSerializer|XPathExpression|XPathResult + |XSLTProcessor))\b(?!\$) + captures: + '1': { name: support.variable.dom.ts } + '2': { name: support.class.dom.ts } + - match: |- + (?x) {{propertyAccess}} \s* (?: + (ATTRIBUTE_NODE|CDATA_SECTION_NODE|COMMENT_NODE|DOCUMENT_FRAGMENT_NODE|DOCUMENT_NODE|DOCUMENT_TYPE_NODE + |DOMSTRING_SIZE_ERR|ELEMENT_NODE|ENTITY_NODE|ENTITY_REFERENCE_NODE|HIERARCHY_REQUEST_ERR|INDEX_SIZE_ERR + |INUSE_ATTRIBUTE_ERR|INVALID_CHARACTER_ERR|NO_DATA_ALLOWED_ERR|NO_MODIFICATION_ALLOWED_ERR|NOT_FOUND_ERR + |NOT_SUPPORTED_ERR|NOTATION_NODE|PROCESSING_INSTRUCTION_NODE|TEXT_NODE|WRONG_DOCUMENT_ERR) + | + (_content|[xyz]|abbr|above|accept|acceptCharset|accessKey|action|align|[av]Link(?:color)?|all|alt|anchors|appCodeName + |appCore|applets|appMinorVersion|appName|appVersion|archive|areas|arguments|attributes|availHeight|availLeft|availTop + |availWidth|axis|background|backgroundColor|backgroundImage|below|bgColor|body|border|borderBottomWidth|borderColor + |borderLeftWidth|borderRightWidth|borderStyle|borderTopWidth|borderWidth|bottom|bufferDepth|callee|caller|caption + |cellPadding|cells|cellSpacing|ch|characterSet|charset|checked|childNodes|chOff|cite|classes|className|clear + |clientInformation|clip|clipBoardData|closed|code|codeBase|codeType|color|colorDepth|cols|colSpan|compact|complete + |components|content|controllers|cookie|cookieEnabled|cords|cpuClass|crypto|current|data|dateTime|declare|defaultCharset + |defaultChecked|defaultSelected|defaultStatus|defaultValue|defaultView|defer|description|dialogArguments|dialogHeight + |dialogLeft|dialogTop|dialogWidth|dir|directories|disabled|display|docmain|doctype|documentElement|elements|embeds + |enabledPlugin|encoding|enctype|entities|event|expando|external|face|fgColor|filename|firstChild|fontFamily|fontSize + |fontWeight|form|formName|forms|frame|frameBorder|frameElement|frames|hasFocus|hash|headers|height|history|host + |hostname|href|hreflang|hspace|htmlFor|httpEquiv|id|ids|ignoreCase|images|implementation|index|innerHeight|innerWidth + |input|isMap|label|lang|language|lastChild|lastIndex|lastMatch|lastModified|lastParen|layer[sXY]|left|leftContext + |lineHeight|link|linkColor|links|listStyleType|localName|location|locationbar|longDesc|lowsrc|lowSrc|marginBottom + |marginHeight|marginLeft|marginRight|marginTop|marginWidth|maxLength|media|menubar|method|mimeTypes|multiline|multiple + |name|nameProp|namespaces|namespaceURI|next|nextSibling|nodeName|nodeType|nodeValue|noHref|noResize|noShade|notationName + |notations|noWrap|object|offscreenBuffering|onLine|onreadystatechange|opener|opsProfile|options|oscpu|outerHeight + |outerWidth|ownerDocument|paddingBottom|paddingLeft|paddingRight|paddingTop|page[XY]|page[XY]Offset|parent|parentLayer + |parentNode|parentWindow|pathname|personalbar|pixelDepth|pkcs11|platform|plugins|port|prefix|previous|previousDibling + |product|productSub|profile|profileend|prompt|prompter|protocol|publicId|readOnly|readyState|referrer|rel|responseText + |responseXML|rev|right|rightContext|rowIndex|rows|rowSpan|rules|scheme|scope|screen[XY]|screenLeft|screenTop|scripts + |scrollbars|scrolling|sectionRowIndex|security|securityPolicy|selected|selectedIndex|selection|self|shape|siblingAbove + |siblingBelow|size|source|specified|standby|start|status|statusbar|statusText|style|styleSheets|suffixes|summary + |systemId|systemLanguage|tagName|tags|target|tBodies|text|textAlign|textDecoration|textIndent|textTransform|tFoot|tHead + |title|toolbar|top|type|undefined|uniqueID|updateInterval|URL|URLUnencoded|useMap|userAgent|userLanguage|userProfile + |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*{{typeParameters}}?\() + captures: + '1': { name: punctuation.accessor.ts } + '2': { name: punctuation.accessor.optional.ts } + '3': { name: support.constant.dom.ts } + '4': { name: support.variable.property.dom.ts } + # Node + - name: support.class.node.ts + match: |- + (?x){{startOfIdentifier}}(Buffer|EventEmitter|Server|Pipe|Socket|REPLServer|ReadStream|WriteStream|Stream + |Inflate|Deflate|InflateRaw|DeflateRaw|GZip|GUnzip|Unzip|Zip)\b(?!\$) + - match: |- + (?x){{startOfIdentifier}}(process)(?:{{propertyAccess}}(?: + (arch|argv|config|connected|env|execArgv|execPath|exitCode|mainModule|pid|platform|release|stderr|stdin|stdout|title|version|versions) + | + (abort|chdir|cwd|disconnect|exit|[sg]ete?[gu]id|send|[sg]etgroups|initgroups|kill|memoryUsage|nextTick|umask|uptime|hrtime) + ))?\b(?!\$) + captures: + '1': { name: support.variable.object.process.ts } + '2': { name: punctuation.accessor.ts } + '3': { name: punctuation.accessor.optional.ts } + '4': { name: support.variable.property.process.ts } + '5': { name: support.function.process.ts } + - match: '{{startOfIdentifier}}(?:(exports)|(module)(?:{{propertyAccess}}(exports|id|filename|loaded|parent|children))?)\b(?!\$)' + captures: + '1': { name: support.type.object.module.ts } + '2': { name: support.type.object.module.ts } + '3': { name: punctuation.accessor.ts } + '4': { name: punctuation.accessor.optional.ts } + '5': { name: support.type.object.module.ts } + - name: support.variable.object.node.ts + match: '{{startOfIdentifier}}(global|GLOBAL|root|__dirname|__filename)\b(?!\$)' + # method calls + - match: |- + (?x) {{propertyAccess}} \s* + (?: + (on(?:Rowsinserted|Rowsdelete|Rowenter|Rowexit|Resize|Resizestart|Resizeend|Reset| + Readystatechange|Mouseout|Mouseover|Mousedown|Mouseup|Mousemove| + Before(?:cut|deactivate|unload|update|paste|print|editfocus|activate)| + Blur|Scrolltop|Submit|Select|Selectstart|Selectionchange|Hover|Help| + Change|Contextmenu|Controlselect|Cut|Cellchange|Clock|Close|Deactivate| + Datasetchanged|Datasetcomplete|Dataavailable|Drop|Drag|Dragstart|Dragover| + Dragdrop|Dragenter|Dragend|Dragleave|Dblclick|Unload|Paste|Propertychange|Error| + Errorupdate|Keydown|Keyup|Keypress|Focus|Load|Activate|Afterupdate|Afterprint|Abort) + ) | + (shift|showModelessDialog|showModalDialog|showHelp|scroll|scrollX|scrollByPages| + scrollByLines|scrollY|scrollTo|stop|strike|sizeToContent|sidebar|signText|sort| + sup|sub|substr|substring|splice|split|send|set(?:Milliseconds|Seconds|Minutes|Hours| + Month|Year|FullYear|Date|UTC(?:Milliseconds|Seconds|Minutes|Hours|Month|FullYear|Date)| + Time|Hotkeys|Cursor|ZOptions|Active|Resizable|RequestHeader)|search|slice| + savePreferences|small|home|handleEvent|navigate|char|charCodeAt|charAt|concat| + contextual|confirm|compile|clear|captureEvents|call|createStyleSheet|createPopup| + createEventObject|to(?:GMTString|UTCString|String|Source|UpperCase|LowerCase|LocaleString)| + test|taint|taintEnabled|indexOf|italics|disableExternalCapture|dump|detachEvent|unshift| + untaint|unwatch|updateCommands|join|javaEnabled|pop|push|plugins.refresh|paddings|parse| + print|prompt|preference|enableExternalCapture|exec|execScript|valueOf|UTC|find|file| + fileModifiedDate|fileSize|fileCreatedDate|fileUpdatedDate|fixed|fontsize|fontcolor| + forward|fromCharCode|watch|link|load|lastIndexOf|anchor|attachEvent|atob|apply|alert| + abort|routeEvents|resize|resizeBy|resizeTo|recalc|returnValue|replace|reverse|reload| + releaseCapture|releaseEvents|go|get(?:Milliseconds|Seconds|Minutes|Hours|Month|Day|Year|FullYear| + Time|Date|TimezoneOffset|UTC(?:Milliseconds|Seconds|Minutes|Hours|Day|Month|FullYear|Date)| + Attention|Selection|ResponseHeader|AllResponseHeaders)|moveBy|moveBelow|moveTo| + moveToAbsolute|moveAbove|mergeAttributes|match|margins|btoa|big|bold|borderWidths|blink|back + ) | + (acceptNode|add|addEventListener|addTextTrack|adoptNode|after|animate|append| + appendChild|appendData|before|blur|canPlayType|captureStream| + caretPositionFromPoint|caretRangeFromPoint|checkValidity|clear|click| + cloneContents|cloneNode|cloneRange|close|closest|collapse| + compareBoundaryPoints|compareDocumentPosition|comparePoint|contains| + convertPointFromNode|convertQuadFromNode|convertRectFromNode|createAttribute| + createAttributeNS|createCaption|createCDATASection|createComment| + createContextualFragment|createDocument|createDocumentFragment| + createDocumentType|createElement|createElementNS|createEntityReference| + createEvent|createExpression|createHTMLDocument|createNodeIterator| + createNSResolver|createProcessingInstruction|createRange|createShadowRoot| + createTBody|createTextNode|createTFoot|createTHead|createTreeWalker|delete| + deleteCaption|deleteCell|deleteContents|deleteData|deleteRow|deleteTFoot| + deleteTHead|detach|disconnect|dispatchEvent|elementFromPoint|elementsFromPoint| + enableStyleSheetsForSet|entries|evaluate|execCommand|exitFullscreen| + exitPointerLock|expand|extractContents|fastSeek|firstChild|focus|forEach|get| + getAll|getAnimations|getAttribute|getAttributeNames|getAttributeNode| + getAttributeNodeNS|getAttributeNS|getBoundingClientRect|getBoxQuads| + getClientRects|getContext|getDestinationInsertionPoints|getElementById| + getElementsByClassName|getElementsByName|getElementsByTagName| + getElementsByTagNameNS|getItem|getNamedItem|getSelection|getStartDate| + getVideoPlaybackQuality|has|hasAttribute|hasAttributeNS|hasAttributes| + hasChildNodes|hasFeature|hasFocus|importNode|initEvent|insertAdjacentElement| + insertAdjacentHTML|insertAdjacentText|insertBefore|insertCell|insertData| + insertNode|insertRow|intersectsNode|isDefaultNamespace|isEqualNode| + isPointInRange|isSameNode|item|key|keys|lastChild|load|lookupNamespaceURI| + lookupPrefix|matches|move|moveAttribute|moveAttributeNode|moveChild| + moveNamedItem|namedItem|nextNode|nextSibling|normalize|observe|open| + parentNode|pause|play|postMessage|prepend|preventDefault|previousNode| + previousSibling|probablySupportsContext|queryCommandEnabled| + queryCommandIndeterm|queryCommandState|queryCommandSupported|queryCommandValue| + querySelector|querySelectorAll|registerContentHandler|registerElement| + registerProtocolHandler|releaseCapture|releaseEvents|remove|removeAttribute| + removeAttributeNode|removeAttributeNS|removeChild|removeEventListener| + removeItem|replace|replaceChild|replaceData|replaceWith|reportValidity| + requestFullscreen|requestPointerLock|reset|scroll|scrollBy|scrollIntoView| + scrollTo|seekToNextFrame|select|selectNode|selectNodeContents|set|setAttribute| + setAttributeNode|setAttributeNodeNS|setAttributeNS|setCapture| + setCustomValidity|setEnd|setEndAfter|setEndBefore|setItem|setNamedItem| + setRangeText|setSelectionRange|setSinkId|setStart|setStartAfter|setStartBefore| + slice|splitText|stepDown|stepUp|stopImmediatePropagation|stopPropagation| + submit|substringData|supports|surroundContents|takeRecords|terminate|toBlob| + toDataURL|toggle|toString|values|write|writeln + ) | + (all|catch|finally|race|reject|resolve|then + ) + )(?=\s*\() + captures: + '1': { name: punctuation.accessor.ts } + '2': { name: punctuation.accessor.optional.ts } + '3': { name: support.function.event-handler.ts } + '4': { name: support.function.ts } + '5': { name: support.function.dom.ts } + '6': { name: support.function.promise.ts } + + identifiers: + patterns: + - include: '#object-identifiers' + # function and method assignment + - match: |- + (?x)(?:{{propertyAccess}}\s*)?({{identifier}})(?=\s*={{functionOrArrowLookup}}) + captures: + '1': { name: punctuation.accessor.ts } + '2': { name: punctuation.accessor.optional.ts } + '3': { name: entity.name.function.ts } + # const properties + - match: '{{propertyAccess}}\s*({{constantPropertyIdentifier}})(?![_$[:alnum:]])' + captures: + '1': { name: punctuation.accessor.ts } + '2': { name: punctuation.accessor.optional.ts } + '3': { name: variable.other.constant.property.ts } + # properties + - match: '{{propertyAccess}}\s*({{propertyIdentifier}})' + captures: + '1': { name: punctuation.accessor.ts } + '2': { name: punctuation.accessor.optional.ts } + '3': { name: variable.other.property.ts } + # const + - name: variable.other.constant.ts + match: '{{constantVar}}' + # vars + - name: variable.other.readwrite.ts + match: '{{identifier}}' + + object-identifiers: + patterns: + # class + - name: support.class.ts + match: ({{identifier}})(?=\s*{{propertyAccessPreIdentifier}}prototype\b(?!\$)) + # object properties + - match: |- + (?x){{propertyAccess}}\s*(?: + ({{constantPropertyIdentifier}}) | + ({{propertyIdentifier}}) + )(?=\s*{{propertyAccessPreIdentifier}}{{propertyIdentifier}}) + captures: + '1': { name: punctuation.accessor.ts } + '2': { name: punctuation.accessor.optional.ts } + '3': { name: variable.other.constant.object.property.ts } + '4': { name: variable.other.object.property.ts } + # objects + - match: |- + (?x)(?: + ({{constantIdentifier}}) | + ({{identifier}}) + )(?=\s*{{propertyAccessPreIdentifier}}{{propertyIdentifier}}) + captures: + '1': { name: variable.other.constant.object.ts } + '2': { name: variable.other.object.ts } + + #type annotation + type-annotation: + patterns: + # if type starts on same line use end of line as end + - name: meta.type.annotation.ts + begin: (:)(?=\s*\S) + beginCaptures: + '1': { name: keyword.operator.type.annotation.ts } + end: (?])|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{))) + patterns: + - include: '#type' + # if type starts on next line use modified line endings as end of type annotation eg. complete empty line + - name: meta.type.annotation.ts + begin: (:) + beginCaptures: + '1': { name: keyword.operator.type.annotation.ts } + end: (?])|(?=^\s*$)|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{))) + patterns: + - include: '#type' + + parameter-type-annotation: + patterns: + - name: meta.type.annotation.ts + begin: (:) + beginCaptures: + '1': { name: keyword.operator.type.annotation.ts } + end: (?=[,)])|(?==[^>]) + patterns: + - include: '#type' + + #return type + return-type: + patterns: + # if type starts on same line use end of line as end + - name: meta.return.type.ts + begin: (?<=\))\s*(:)(?=\s*\S) + beginCaptures: + '1': { name: keyword.operator.type.annotation.ts } + end: (?'' can be matched as return type of arrow + possibly-arrow-return-type: + begin: (?<=\)|^)\s*(:)(?={{possiblyType}}\s*=>) beginCaptures: - '1': { name: storage.type.ts } - '2': { name: storage.modifier.ts } - '3': { name: storage.type.function.ts } - '4': { name: entity.name.function.ts } - end: (?=;|\})|(?<=\}) + '1': { name: meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts } + end: '{{arrowFunctionEnd}}' + contentName: meta.arrow.ts meta.return.type.arrow.ts patterns: - - include: '#comment' - - include: '#type-parameters' - - include: '#function-type-parameters' - - include: '#return-type' - - include: '#function-overload-declaration' - - include: '#decl-block' + - include: '#arrow-return-type-body' - function-overload-declaration: - name: meta.function.overload.ts - match: \b(?:(export)\s+)?(function\b)(?:\s+([a-zA-Z_$][\w$]*))?\s* - captures: - '1': { name: storage.type.ts } - '2': { name: storage.type.function.ts } - '3': { name: entity.name.function.ts } + arrow-return-type-body: + patterns: + # TODO: handle the fn and constructor type specifically. + # Handle returning of object type specifically here so as to not confuse it with the start of function block + - begin: (?<=[:])(?=\s*\{) + end: (?<=\}) + patterns: + - include: '#type-object' + - include: '#type-predicate-operator' + - include: '#type' - block: - name: meta.block.ts - begin: \{ + #type parameters + type-parameters: + name: meta.type.parameters.ts + begin: '(<)' beginCaptures: - '0': { name: meta.brace.curly.ts } - end: \} + '1': { name: punctuation.definition.typeparameters.begin.ts } + end: '(>)' endCaptures: - '0': { name: meta.brace.curly.ts } + '1': { name: punctuation.definition.typeparameters.end.ts } patterns: - - include: '#object-member' - - include: '#expression' + - include: '#comment' + - name: storage.modifier.ts + match: '{{startOfIdentifier}}(extends|in|out|const){{endOfIdentifier}}' + - include: '#type' + - include: '#punctuation-comma' + - name: keyword.operator.assignment.ts + match: (=)(?!>) - decl-block: - name: meta.decl.block.ts - begin: \{ + #type arguments + type-arguments: + name: meta.type.parameters.ts + begin: \< beginCaptures: - '0': { name: meta.brace.curly.ts } - end: \} + '0': { name: punctuation.definition.typeparameters.begin.ts } + end: \> endCaptures: - '0': { name: meta.brace.curly.ts } - patterns: - - include: '#expression' - - parameter-name: - name: parameter.name.ts - match: '(?:\s*\b(public|private|protected)\b\s+)?(\.\.\.)?\s*([a-zA-Z_$][\w$]*)\s*(\??)' - captures: - '1': { name: storage.modifier.ts } - '2': { name: keyword.others.ts } - '3': { name: variable.parameter.ts } - '4': { name: keyword.others.ts } - - return-type: - name: meta.return.type.ts - begin: '(?<=\))\s*:' - end: (?=$)|(?=\{|;|//) + '0': { name: punctuation.definition.typeparameters.end.ts } patterns: - - include: '#type' + - include: '#type-arguments-body' - type-annotation: - name: meta.type.annotation.ts - begin: ":" - end: (?=$|[,);\}\]]|//)|(?==[^>])|(?<=[\}>\]\)]|[a-zA-Z_$])\s*(?=\{) + type-arguments-body: patterns: - - include: '#expression-operator' + - match: '{{startOfIdentifier}}(_){{endOfIdentifier}}' + captures: + '0': { name: keyword.operator.type.ts } - include: '#type' - - include: '#string' - - include: '#comment' + - include: '#punctuation-comma' + #different types type: - name: meta.type.ts patterns: + - include: '#comment' + - include: '#type-string' + - include: '#numeric-literal' - include: '#type-primitive' + - include: '#type-builtin-literals' - include: '#type-parameters' - include: '#type-tuple' - include: '#type-object' - - include: '#type-operator' - - include: '#type-paren-or-function-type-parameters' + - include: '#type-operators' + - include: '#type-conditional' + - include: '#type-fn-type-parameters' + - include: '#type-paren-or-function-parameters' - include: '#type-function-return-type' + - match: '{{startOfIdentifier}}(readonly){{endOfIdentifier}}\s*' + captures: + '1': { name: storage.modifier.ts } - include: '#type-name' - function-type-parameters: - name: meta.function.type.parameter.ts - begin: \( - beginCaptures: - '0': { name: meta.brace.round.ts } - end: \) - endCaptures: - '0': { name: meta.brace.round.ts } - patterns: - - include: '#comment' - - include: '#parameter-name' - - include: '#type-annotation' - - include: '#variable-initializer' - type-primitive: - name: meta.type.primitive.ts - match: '\b(string|number|boolean|symbol|any|void)\b' - captures: - '1': { name: support.type.ts } - - # Parenthesis can contain either types and function parameters - # (number | string) or (param: number, param2: string) - # and it can be nested, for example - # (number | (param: number, param2: string) => void) - type-paren-or-function-type-parameters: - name: meta.type.paren.cover.ts - begin: '(?:\b(new)\b)?\s*\(' - beginCaptures: - '1': { name: keyword.control.ts } - end: '\)' - patterns: - - include: '#comment' - - include: '#type' - - include: '#function-type-parameters' - - await-modifier: - name: storage.modifier.ts - match: '\bawait\b' - - type-operator: - name: keyword.operator.type.ts - match: '[.|]' + name: support.type.primitive.ts + match: '{{startOfIdentifier}}(string|number|bigint|boolean|symbol|any|void|never|unknown){{endOfIdentifier}}' - type-function-return-type: - name: meta.type.function.return.ts - begin: '=>' - beginCaptures: - '0': { name: keyword.operator.ts } - end: (?=\s*[,\)\{=;>]|//|$) - patterns: - - include: '#type' + type-builtin-literals: + name: support.type.builtin.ts + match: '{{startOfIdentifier}}(this|true|false|undefined|null|object){{endOfIdentifier}}' type-tuple: name: meta.type.tuple.ts @@ -387,325 +2418,914 @@ repository: endCaptures: '0': { name: meta.brace.square.ts } patterns: + - name: keyword.operator.rest.ts + match: \.\.\. + - match: '{{startOfIdentifier}}({{identifier}})\s*(\?)?\s*(:)' + captures: + '1': { name: entity.name.label.ts } + '2': { name: keyword.operator.optional.ts } + '3': { name: punctuation.separator.label.ts } - include: '#type' - - include: '#comment' - - type-name: - name: meta.type.name.ts - match: '[a-zA-Z_$][.\w$]*' - captures: - '1': { name: entity.name.type.ts } + - include: '#punctuation-comma' - type-parameters: - name: meta.type.parameters.ts - begin: '([a-zA-Z_$][\w$]*)?(<)' + type-object: + name: meta.object.type.ts + begin: \{ beginCaptures: - '1': { name: entity.name.type.ts } - '2': { name: meta.brace.angle.ts } - end: '(?=$)|(>)' + '0': { name: punctuation.definition.block.ts } + end: \} endCaptures: - '2': { name: meta.brace.angle.ts } + '0': { name: punctuation.definition.block.ts } patterns: - - name: keyword.other.ts - match: '\b(extends)\b' - include: '#comment' + - include: '#method-declaration' + - include: '#indexer-declaration' + - include: '#indexer-mapped-type-declaration' + - include: '#field-declaration' + - include: '#type-annotation' + - begin: \.\.\. + beginCaptures: + '0': { name: keyword.operator.spread.ts } + end: '(?=\}|;|,|$)|(?<=\})' + patterns: + - include: '#type' + - include: '#punctuation-comma' + - include: '#punctuation-semicolon' - include: '#type' - variable-initializer: - begin: (=) - beginCaptures: - '1': { name: keyword.operator.comparison.ts } - end: (?=$|[,);=]) - patterns: - - include: '#expression' - - expression: - name: meta.expression.ts + #conditional type + type-conditional: patterns: - - include: '#for-in-simple' - - include: '#string' - - include: '#regex' - - include: '#template' - - include: '#comment' - - include: '#literal' - - include: '#paren-expression' - - include: '#var-expr' - - include: '#declaration' - - include: '#cast' - - include: '#new-expr' - - include: '#switch-statement' - - include: '#block' - - include: '#import-operator' - - include: '#expression-operator' - - include: '#imply-operator' - - include: '#relational-operator' - - include: '#arithmetic-operator' - - include: '#logic-operator' - - include: '#assignment-operator' - - include: '#storage-keyword' - - include: '#type-primitive' - - include: '#function-call' - - include: '#case-clause' - - include: '#control-statement' + - begin: '{{startOfIdentifier}}(extends)\s+' + beginCaptures: + '1': { name: storage.modifier.ts } + end: (?<=:) + patterns: + - begin: \? + beginCaptures: + '0': { name: keyword.operator.ternary.ts } + end: ':' + endCaptures: + '0': { name: keyword.operator.ternary.ts } + patterns: + - include: '#type' + - include: '#type' - switch-expression: - name: switch-expression.expr.ts - begin: \b(switch)\b\s*\( + # Parenthesis can contain either types and function parameters + # (number | string) or (param: number, param2: string) + # and it can be nested, for example + # (number | (param: number, param2: string) => void) + type-paren-or-function-parameters: + name: meta.type.paren.cover.ts + begin: \( beginCaptures: - '1': { name: keyword.control.ts } + '0': { name: meta.brace.round.ts } end: \) + endCaptures: + '0': { name: meta.brace.round.ts } patterns: - - include: '#expression' - - switch-block: - name: switch-block.expr.ts - begin: '{' - end: (?=\}) - patterns: - - include: '#expression' + #parameter name only if followed by type annotation + - match: |- + (?x)(?:{{startOfIdentifier}}(public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?) + patterns: + - include: '#comment' + - include: '#type-parameters' + - name: meta.type.constructor.ts + begin: '{{startOfIdentifier}}(?:(abstract)\s+)?(new)\b\s*(?=\()' + beginCaptures: + '1': { name: storage.modifier.ts } # captures keyword (abstract) + '2': { name: keyword.control.new.ts } # captures keyword (new) + end: (?<=\)) + patterns: + - include: '#function-parameters' + # () | (... | (param: | (param, | (param? | (param= | (param) => + - name: meta.type.function.ts + begin: |- + (?x)( + (?= + [(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + ) + ) + ) + end: (?<=\)) + patterns: + - include: '#function-parameters' - switch-statement: - name: switch-statement.expr.ts - begin: (?=\bswitch\b\s*\() - end: '}' + type-function-return-type: patterns: - - include: '#switch-expression' - - include: '#switch-block' - - for-in-simple: - name: forin.expr.ts - match: (?<=\()\s*\b(var|let|const)\s+([a-zA-Z_$][\w$]*)\s+(in|of)\b - captures: - '1': { name: storage.type.ts } - '3': { name: keyword.others.ts } + # if type starts on same line use end of line as end + - name: meta.type.function.return.ts + begin: (=>)(?=\s*\S) + beginCaptures: + '1': { name: storage.type.function.arrow.ts } + end: (?)(?:\?]|//|$) + patterns: + - include: '#type-function-return-type-core' + # if type starts on next line use modified line endings as end of type annotation eg. complete empty line + - name: meta.type.function.return.ts + begin: '=>' + beginCaptures: + '0': { name: storage.type.function.arrow.ts } + end: (?)(?]|//|^\s*$)|((?<=\S)(?=\s*$))) + patterns: + - include: '#type-function-return-type-core' + + type-function-return-type-core: + patterns: + - include: '#comment' + # Handle returning of object type specifically here so as to not confuse it with the start of function block + - begin: (?<==>)(?=\s*\{) + end: (?<=\}) + patterns: + - include: '#type-object' + - include: '#type-predicate-operator' + - include: '#type' - function-call: - name: functioncall.expr.ts + #type operators + type-operators: patterns: - - include: '#await-modifier' - - include: '#type-parameters' - - include: '#paren-expression' - - cast: - name: cast.expr.ts - # We need to differentiate between the relational '<' operator and the beginning of a type assertion/cast using the surrounding context. - # If '<' is preceeded by 'return', 'throw', 'yield', or 'await', it's most likely a type assertion - # If '=', '(', ',', ':', or '>' are followed by a '<', it is also likely a type assertion as otherwise it would be a syntax error - # '<=' and '<<=' are cannot be type assertions, as they are assignment operators. - begin: '(?:(?<=return|throw|yield|await|[=(,:>]))\s*(<)(?!' - endCaptures: - '0': { name: meta.brace.angle.ts } + - include: '#typeof-operator' + - include: '#type-infer' + # Handle the object types followed by | or & operator as { can be used as end of Type in many places and this avoids tripping that + - begin: ([&|])(?=\s*\{) + beginCaptures: + '0': { name: keyword.operator.type.ts } + end: (?<=\}) + patterns: + - include: '#type-object' + # capture all white spaces followed by the | or & operator so that line break (which is end regex for many type patterns) + # will be consumed and we will continue to be in type space + - begin: '[&|]' + beginCaptures: + '0': { name: keyword.operator.type.ts } + end: (?=\S) + - name: keyword.operator.expression.keyof.ts + match: '{{startOfIdentifier}}keyof{{endOfIdentifier}}' + - name: keyword.operator.ternary.ts + match: (\?|\:) + - name: keyword.operator.expression.import.ts + match: '{{startOfIdentifier}}import(?=\s*\()' + + type-infer: patterns: - - include: '#type' - - new-expr: - name: new.expr.ts - begin: '\b(new)\b' - beginCaptures: - '1': { name: keyword.others.ts } - # new-expr ends just before any type or call arguments. Type arguments will be picked up by #cast. - end: '(?=[(;]|$)' + - match: '{{startOfIdentifier}}(infer)\s+({{identifier}}){{endOfIdentifier}}(?:\s+(extends){{endOfIdentifier}})?' + name: meta.type.infer.ts + captures: + '1': { name: keyword.operator.expression.infer.ts } + '2': { name: entity.name.type.ts } + '3': { name: keyword.operator.expression.extends.ts } + + type-predicate-operator: patterns: - - include: '#type' - - include: '#comment' - - object-member: - name: meta.object.member.ts - begin: '[a-zA-Z_$][\w$]*\s*:' - end: (?=,|\}) + - match: '{{startOfIdentifier}}(?:(asserts)\s+)?(?!asserts)(?:(this)|({{identifier}}))\s(is){{endOfIdentifier}}' + captures: + '1': { name: keyword.operator.type.asserts.ts } + '2': { name: variable.parameter.ts variable.language.this.ts } + '3': { name: variable.parameter.ts } + '4': { name: keyword.operator.expression.is.ts } + - match: '{{startOfIdentifier}}(asserts)\s+(?!is)(?:(this)|({{identifier}})){{endOfIdentifier}}' + captures: + '1': { name: keyword.operator.type.asserts.ts } + '2': { name: variable.parameter.ts variable.language.this.ts } + '3': { name: variable.parameter.ts } + - name: keyword.operator.type.asserts.ts + match: '{{startOfIdentifier}}asserts{{endOfIdentifier}}' + - name: keyword.operator.expression.is.ts + match: '{{startOfIdentifier}}is{{endOfIdentifier}}' + + #name of the type and type name followed by type arguments + type-name: patterns: - - include: '#expression' - - expression-operator: - name: keyword.others.ts - match: \b(delete|in|instanceof|new|typeof|as|is|of)\b - - imply-operator: - name: keyword.operator.ts - match: => - - import-operator: - name: keyword.control.import.include.ts - match: \b(import|from)\b - - arithmetic-operator: - name: keyword.operator.arithmetic.ts - match: \*|/|\-\-|\-|\+\+|\+|% - - relational-operator: - name: keyword.operator.comparison.ts - match: ===|!==|==|!=|<=|>=|<>|=|<|> - - assignment-operator: - name: keyword.operator.assignment.ts - match: <<=|>>>=|>>=|\*=|(?)' + endCaptures: + '1': { name: meta.type.parameters.ts punctuation.definition.typeparameters.end.ts } + contentName: meta.type.parameters.ts + patterns: + - include: '#type-arguments-body' + - begin: '({{identifier}})\s*(<)' + beginCaptures: + '1': { name: entity.name.type.ts } + '2': { name: meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts } + end: '(>)' + endCaptures: + '1': { name: meta.type.parameters.ts punctuation.definition.typeparameters.end.ts } + contentName: meta.type.parameters.ts + patterns: + - include: '#type-arguments-body' + - match: ({{identifier}})\s*{{propertyAccess}} + captures: + '1': { name: entity.name.type.module.ts } + '2': { name: punctuation.accessor.ts } + '3': { name: punctuation.accessor.optional.ts } + - name: entity.name.type.ts + match: '{{identifier}}' + + #punctuations + punctuation-comma: + name: punctuation.separator.comma.ts + match: ',' + + punctuation-semicolon: + name: punctuation.terminator.statement.ts + match: ';' + + punctuation-accessor: + match: '{{propertyAccess}}' + captures: + '1': { name: punctuation.accessor.ts } + '2': { name: punctuation.accessor.optional.ts } - paren-expression: - begin: \( - beginCaptures: - '0': {name: meta.brace.paren.ts } - end: \) - endCaptures: - '0': {name: meta.brace.paren.ts } + #strings and template strings + string: patterns: - - include: '#expression' + - include: '#qstring-single' + - include: '#qstring-double' + - include: '#template' qstring-double: - name: string.double.ts + name: string.quoted.double.ts begin: '"' - end: '"|(?:[^\\\n]$)' + beginCaptures: + '0': { name: punctuation.definition.string.begin.ts } + end: '(")|((?:[^\\\n])$)' + endCaptures: + '1': { name: punctuation.definition.string.end.ts } + '2': { name: invalid.illegal.newline.ts } patterns: - include: '#string-character-escape' qstring-single: - name: string.single.ts + name: string.quoted.single.ts begin: "'" - end: \'|(?:[^\\\n]$) + beginCaptures: + '0': { name: punctuation.definition.string.begin.ts } + end: (\')|((?:[^\\\n])$) + endCaptures: + '1': { name: punctuation.definition.string.end.ts } + '2': { name: invalid.illegal.newline.ts } patterns: - include: '#string-character-escape' - regex: - name: string.regex.ts - begin: (?<=[=(:,\[]|^|return|&&|\|\||!)\s*(/)(?![/*+{}?]) - end: $|(/)[igm]* - patterns: - - name: constant.character.escape.ts - match: \\. - - name: constant.character.class.ts - match: \[(\\\]|[^\]])*\] - - string: - name: string.ts - patterns: - - include: '#qstring-single' - - include: '#qstring-double' + string-character-escape: + name: constant.character.escape.ts + match: \\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\{[0-9A-Fa-f]+\}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$) template: - name: meta.template.ts - begin: '`' - beginCaptures: - '0': { name: string.template.ts} - end: '`' - endCaptures: - '0': { name: string.template.ts} patterns: - - include: '#template-substitution-element' - - include: '#template-string-contents' - - template-string-contents: - name: string.template.ts - begin: '.*?' - end: (?=(\$\{|`)) + - include: '#template-call' + - contentName: string.template.ts + begin: '({{identifier}})?(`)' + beginCaptures: + '1': { name: entity.name.function.tagged-template.ts } + '2': { name: string.template.ts punctuation.definition.string.template.begin.ts } + end: '`' + endCaptures: + '0': { name: string.template.ts punctuation.definition.string.template.end.ts} + patterns: + - include: '#template-substitution-element' + - include: '#string-character-escape' + + template-call: patterns: - - include: '#string-character-escape' - - string-character-escape: - name: constant.character.escape - match: \\(x\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$) + - begin: (?=(({{identifier}}\s*{{propertyAccessPreIdentifier}})*|({{propertyAccessPreIdentifier}})?)({{identifier}})({{typeArguments}}\s*)?`) + end: (?=`) + patterns: + - begin: (?=(({{identifier}}\s*{{propertyAccessPreIdentifier}})*|({{propertyAccessPreIdentifier}})?)({{identifier}})) + end: (?=({{typeArguments}}\s*)?`) + patterns: + - include: '#support-function-call-identifiers' + - name: entity.name.function.tagged-template.ts + match: ({{identifier}}) + - include: '#type-arguments' + - begin: ({{identifier}})?\s*(?=({{typeArguments}}\s*)`) + beginCaptures: + '1': { name: entity.name.function.tagged-template.ts } + end: (?=`) + patterns: + - include: '#type-arguments' template-substitution-element: - name: template.element.ts + name: meta.template.expression.ts begin: \$\{ beginCaptures: - '0': {name: keyword.others.ts} + '0': { name: punctuation.definition.template-expression.begin.ts } end: \} endCaptures: - '0': {name: keyword.others.ts} + '0': { name: punctuation.definition.template-expression.end.ts } patterns: - include: '#expression' + contentName: meta.embedded.line.ts - comment: - name: comment.ts + type-string: patterns: - - include: '#comment-block-doc' - - include: '#comment-block' - - include: '#comment-line' - - comment-block-doc: - name: comment.block.documentation.ts - begin: /\*\*(?!/) - end: \*/ - - comment-block: - name: comment.block.ts - begin: /\* - end: \*/ - - comment-line: - name: comment.line.ts - match: (//).*$\n? + - include: '#qstring-single' + - include: '#qstring-double' + - include: '#template-type' - literal: - name: literal.ts + template-type: patterns: - - include: '#numeric-literal' - - include: '#boolean-literal' - - include: '#null-literal' - - include: '#undefined-literal' - - include: '#array-literal' - - include: '#this-literal' - - array-literal: - name: meta.array.literal.ts - begin: \[ + - include: '#template-call' + - contentName: string.template.ts + begin: '({{identifier}})?(`)' + beginCaptures: + '1': { name: entity.name.function.tagged-template.ts } + '2': { name: string.template.ts punctuation.definition.string.template.begin.ts } + end: '`' + endCaptures: + '0': { name: string.template.ts punctuation.definition.string.template.end.ts} + patterns: + - include: '#template-type-substitution-element' + - include: '#string-character-escape' + + template-type-substitution-element: + name: meta.template.expression.ts + begin: \$\{ beginCaptures: - '0': { name: meta.brace.square.ts } - end: \] + '0': { name: punctuation.definition.template-expression.begin.ts } + end: \} endCaptures: - '0': { name: meta.brace.square.ts } + '0': { name: punctuation.definition.template-expression.end.ts } patterns: - - include: '#expression' - - numeric-literal: - name: constant.numeric.ts - match: \b(?<=[^$])((0(x|X)[0-9a-fA-F]+)|(0(o|O)[0-7]+)|(0(b|B)(0|1)+)|(([0-9]+(\.[0-9]+)?))([eE]([+-]?)[0-9]+(\.[0-9]+)?)?)\b - - boolean-literal: - name: constant.language.boolean.ts - match: \b(false|true)\b - - null-literal: - name: constant.language.null.ts - match: \b(null)\b - - this-literal: - name: constant.language.this.ts - match: \b(this)\b - - undefined-literal: - name: constant.language.ts - match: \b(undefined)\b - - access-modifier: - name: storage.modifier.ts - match: \b(public|protected|private)\b + - include: '#type' + contentName: meta.embedded.line.ts - static-modifier: - name: keyword.other.ts - match: \b(static)\b + #regular expression + # regexp syntax is taken from https://github.com/atom/language-javascript/ + regex: + patterns: + - name: string.regexp.ts + begin: (?|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[\()]|\\.|\[([^\]\\]|\\.)+\]|\(([^\)\\]|\\.)+\))+\/{{regexpTail}}) + beginCaptures: + '1': { name: punctuation.definition.string.begin.ts } + end: (/)([dgimsuvy]*) + endCaptures: + '1': { name: punctuation.definition.string.end.ts } + '2': { name: keyword.other.ts} + patterns: + - include: '#regexp' + # Check if complete regexp syntax + - name: string.regexp.ts + begin: ((? + captures: + '0': { name: keyword.other.back-reference.regexp } + '1': { name: variable.other.regexp } + - name: keyword.operator.quantifier.regexp + match: '[?+*]|\{(\d+,\d+|\d+,|,\d+|\d+)\}\??' + - name: keyword.operator.or.regexp + match: \| + - name: meta.group.assertion.regexp + begin: (\()((\?=)|(\?!)|(\?<=)|(\?))? + beginCaptures: + '0': { name: punctuation.definition.group.regexp } + '1': { name: punctuation.definition.group.no-capture.regexp } + '2': { name: variable.other.regexp } + end: \) + endCaptures: + '0': { name: punctuation.definition.group.regexp } + patterns: + - include: '#regexp' + - name: constant.other.character-class.set.regexp + begin: (\[)(\^)? + beginCaptures: + '1': { name: punctuation.definition.character-class.regexp } + '2': { name: keyword.operator.negation.regexp } + end: (\]) + endCaptures: + '1': {name: punctuation.definition.character-class.regexp } + patterns: + - name: constant.other.character-class.range.regexp + match: (?:.|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.))\-(?:[^\]\\]|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.)) + captures: + '1': { name: constant.character.numeric.regexp } + '2': { name: constant.character.control.regexp } + '3': { name: constant.character.escape.backslash.regexp } + '4': { name: constant.character.numeric.regexp } + '5': { name: constant.character.control.regexp } + '6': { name: constant.character.escape.backslash.regexp } + - include: '#regex-character-class' + - include: '#regex-character-class' + + regex-character-class: + patterns: + - name: constant.other.character-class.regexp + match: \\[wWsSdDtrnvf]|\. + - name: constant.character.numeric.regexp + match: \\([0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}) + - name: constant.character.control.regexp + match: \\c[A-Z] + - name: constant.character.escape.backslash.regexp + match: \\. - property-accessor: - name: storage.type.property.ts - match: \b(get|set)\b + #comments and directives + comment: + patterns: + - name: comment.block.documentation.ts + begin: /\*\*(?!/) + beginCaptures: + '0': { name: punctuation.definition.comment.ts } + end: \*/ + endCaptures: + '0': { name: punctuation.definition.comment.ts } + patterns: + - include: '#docblock' + - name: comment.block.ts + begin: (/\*)(?:\s*((@)internal)(?=\s|(\*/)))? + beginCaptures: + '1': { name: punctuation.definition.comment.ts } + '2': { name: storage.type.internaldeclaration.ts } + '3': { name: punctuation.decorator.internaldeclaration.ts } + end: \*/ + endCaptures: + '0': { name: punctuation.definition.comment.ts } + - begin: (^[ \t]+)?((//)(?:\s*((@)internal)(?=\s|$))?) + beginCaptures: + '1': { name: punctuation.whitespace.comment.leading.ts } + '2': { name: comment.line.double-slash.ts } + '3': { name: punctuation.definition.comment.ts } + '4': { name: storage.type.internaldeclaration.ts } + '5': { name: punctuation.decorator.internaldeclaration.ts } + end: (?=$) + contentName: comment.line.double-slash.ts + + single-line-comment-consuming-line-ending: + begin: (^[ \t]+)?((//)(?:\s*((@)internal)(?=\s|$))?) + beginCaptures: + '1': { name: punctuation.whitespace.comment.leading.ts } + '2': { name: comment.line.double-slash.ts } + '3': { name: punctuation.definition.comment.ts } + '4': { name: storage.type.internaldeclaration.ts } + '5': { name: punctuation.decorator.internaldeclaration.ts } + end: (?=^) + contentName: comment.line.double-slash.ts + + directives: + name: comment.line.triple-slash.directive.ts + begin: ^(///)\s*(?=<(reference|amd-dependency|amd-module)(\s+(path|types|no-default-lib|lib|name|resolution-mode)\s*=\s*({{quotedStrings}}))+\s*/>\s*$) + beginCaptures: + '1': { name: punctuation.definition.comment.ts } + end: (?=$) + patterns: + - name: meta.tag.ts + begin: (<)(reference|amd-dependency|amd-module) + beginCaptures: + '1': { name: punctuation.definition.tag.directive.ts } + '2': { name: entity.name.tag.directive.ts } + end: /> + endCaptures: + '0': { name: punctuation.definition.tag.directive.ts } + patterns: + - name: entity.other.attribute-name.directive.ts + match: 'path|types|no-default-lib|lib|name|resolution-mode' + - name: keyword.operator.assignment.ts + match: '=' + - include: '#string' + + #jsdoc syntax taken from https://github.com/atom/language-javascript/ + #no longer maintained there, however: https://github.com/atom/language-javascript/pull/645#issuecomment-496795093 + docblock: + patterns: + # @access private|protected|public + - match: |- + (?x) + ((@)(?:access|api)) + \s+ + (private|protected|public) + \b + captures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + '3': { name: constant.language.access-type.jsdoc } + # @author name [] + - match: |- + (?x) + ((@)author) + \s+ + ( + [^@\s<>*/] + (?:[^@<>*/]|\*[^/])* + ) + (?: + \s* + (<) + ([^>\s]+) + (>) + )? + captures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + '3': { name: entity.name.type.instance.jsdoc } + '4': { name: punctuation.definition.bracket.angle.begin.jsdoc } + '5': { name: constant.other.email.link.underline.jsdoc } + '6': { name: punctuation.definition.bracket.angle.end.jsdoc } + # @borrows as + - match: |- + (?x) + ((@)borrows) \s+ + ((?:[^@\s*/]|\*[^/])+) # + \s+ (as) \s+ # as + ((?:[^@\s*/]|\*[^/])+) # + captures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + '3': { name: entity.name.type.instance.jsdoc } + '4': { name: keyword.operator.control.jsdoc } + '5': { name: entity.name.type.instance.jsdoc } + # @example text(); + - name: meta.example.jsdoc + begin: ((@)example)\s+ + end: (?=@|\*/) + beginCaptures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + patterns: + # Match to prevent leading asterisk being highlighted as JS + - match: ^\s\*\s+ + # Leading … before example + - contentName: constant.other.description.jsdoc + begin: \G(<)caption(>) + beginCaptures: + '0': { name: entity.name.tag.inline.jsdoc } + '1': { name: punctuation.definition.bracket.angle.begin.jsdoc } + '2': { name: punctuation.definition.bracket.angle.end.jsdoc } + end: ()|(?=\*/) + endCaptures: + '0': { name: entity.name.tag.inline.jsdoc } + '1': { name: punctuation.definition.bracket.angle.begin.jsdoc } + '2': { name: punctuation.definition.bracket.angle.end.jsdoc } + # Highlighted JavaScript example + - match: '[^\s@*](?:[^*]|\*[^/])*' + captures: + '0': + name: source.embedded.ts + # Commenting out the embedded pattern matching since sublime doesnt support this + # patterns: + # - include: source.ts + # @kind type + - match: >- + (?x) + ((@)kind) + \s+ + (class|constant|event|external|file|function|member|mixin|module|namespace|typedef) + \b + captures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + '3': { name: constant.language.symbol-type.jsdoc } + # @see namepathOrURL + - match: |- + (?x) + ((@)see) + \s+ + (?: + # URL + ( + (?=https?://) + (?:[^\s*]|\*[^/])+ + ) + | + # JSDoc namepath + ( + (?! + # Avoid matching bare URIs (also acceptable as links) + https?:// + | + # Avoid matching {@inline tags}; we match those below + (?:\[[^\[\]]*\])? # Possible description [preceding]{@tag} + {@(?:link|linkcode|linkplain|tutorial)\b + ) + # Matched namepath + (?:[^@\s*/]|\*[^/])+ + ) + ) + captures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + '3': { name: variable.other.link.underline.jsdoc } + '4': { name: entity.name.type.instance.jsdoc } + # @template Foo,Bar + - match: |- + (?x) + ((@)template) + \s+ + # One or more valid identifiers + ( + [A-Za-z_$] # First character: non-numeric word character + [\w$.\[\]]* # Rest of identifier + (?: # Possible list of additional identifiers + \s* , \s* + [A-Za-z_$] + [\w$.\[\]]* + )* + ) + captures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + '3': + name: variable.other.jsdoc + # Commenting out the embedded pattern matching since sublime doesnt support this + # patterns: + # - name: punctuation.delimiter.object.comma.jsdoc + # match: ',' + # @template {Constraint} Foo + - begin: (?x)((@)template)\s+(?={) + beginCaptures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + end: (?=\s|\*/|[^{}\[\]A-Za-z_$]) + patterns: + - include: '#jsdoctype' + - name: variable.other.jsdoc + # One valid identifier + match: ([A-Za-z_$][\w$.\[\]]*) + # Tags followed by an identifier token + # - @ identifier + - match: |- + (?x) + ( + (@) + (?:arg|argument|const|constant|member|namespace|param|var) + ) + \s+ + ( + [A-Za-z_$] + [\w$.\[\]]* + ) + captures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + '3': { name: variable.other.jsdoc } + # Tags followed by a type expression, then a namepath + # - @ {type} namepath + - begin: ((@)typedef)\s+(?={) + beginCaptures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + end: (?=\s|\*/|[^{}\[\]A-Za-z_$]) + patterns: + - include: '#jsdoctype' + - name: entity.name.type.instance.jsdoc + match: (?:[^@\s*/]|\*[^/])+ + # Tags followed by a type expression, then an identifier + # - @ {type} identifier + - begin: >- + ((@)(?:arg|argument|const|constant|member|namespace|param|prop|property|var))\s+(?={) + beginCaptures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + end: (?=\s|\*/|[^{}\[\]A-Za-z_$]) + patterns: + - include: '#jsdoctype' + - name: variable.other.jsdoc + match: ([A-Za-z_$][\w$.\[\]]*) + # Optional value + - name: variable.other.jsdoc + match: |- + (?x) + (\[)\s* + [\w$]+ + (?: + (?:\[\])? # Foo[ ].bar properties within an array + \. # Foo.Bar namespaced parameter + [\w$]+ + )* + (?: + \s* + (=) # [foo=bar] Default parameter value + \s* + ( + # The inner regexes are to stop the match early at */ and to not stop at escaped quotes + (?> + "(?:(?:\*(?!/))|(?:\\(?!"))|[^*\\])*?" | # [foo="bar"] Double-quoted + '(?:(?:\*(?!/))|(?:\\(?!'))|[^*\\])*?' | # [foo='bar'] Single-quoted + \[ (?:(?:\*(?!/))|[^*])*? \] | # [foo=[1,2]] Array literal + (?:(?:\*(?!/))|\s(?!\s*\])|\[.*?(?:\]|(?=\*/))|[^*\s\[\]])* # Everything else + )* + ) + )? + \s*(?:(\])((?:[^*\s]|\*[^\s/])+)?|(?=\*/)) + captures: + '1': { name: punctuation.definition.optional-value.begin.bracket.square.jsdoc } + '2': { name: keyword.operator.assignment.jsdoc } + '3': + name: source.embedded.ts + # Commenting out the embedded pattern matching since sublime doesnt support this + # patterns: + # - include: '#inline-tags' + # - include: source.js + '4': { name: punctuation.definition.optional-value.end.bracket.square.jsdoc } + '5': { name: invalid.illegal.syntax.jsdoc } + # Tags followed by a type expression + # - @ {type} + - begin: |- + (?x) + ( + (@) + (?:define|enum|exception|export|extends|lends|implements|modifies + |namespace|private|protected|returns?|satisfies|suppress|this|throws|type + |yields?) + ) + \s+(?={) + beginCaptures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + end: (?=\s|\*/|[^{}\[\]A-Za-z_$]) + patterns: + - include: '#jsdoctype' + # Tags followed by a namepath + # - @ namepath + - match: |- + (?x) + ( + (@) + (?:alias|augments|callback|constructs|emits|event|fires|exports? + |extends|external|function|func|host|lends|listens|interface|memberof!? + |method|module|mixes|mixin|name|requires|see|this|typedef|uses) + ) + \s+ + ( + (?: + [^{}@\s*] | \*[^/] + )+ + ) + captures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + '3': { name: entity.name.type.instance.jsdoc } + # Tags followed by a quoted arbitrary value + # - @ "Quoted value" + - contentName: variable.other.jsdoc + begin: ((@)(?:default(?:value)?|license|version))\s+(([''"])) + beginCaptures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + '3': { name: variable.other.jsdoc } + '4': { name: punctuation.definition.string.begin.jsdoc } + end: (\3)|(?=$|\*/) + endCaptures: + '0': { name: variable.other.jsdoc } + '1': { name: punctuation.definition.string.end.jsdoc } + # Tags followed by an arbitrary value + # - @ value + - match: ((@)(?:default(?:value)?|license|tutorial|variation|version))\s+([^\s*]+) + captures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + '3': { name: variable.other.jsdoc } + # Tags without arguments, or a tag without expected arguments. Because JSDoc permits + # tags to be spread across lines, we should at least highlight the opening tag for + # stuff like this: + # + # /** + # * @param + # * {type} + # * name + - name: storage.type.class.jsdoc + match: >- + (?x) (@) + (?:abstract|access|alias|api|arg|argument|async|attribute|augments|author|beta|borrows|bubbles + |callback|chainable|class|classdesc|code|config|const|constant|constructor|constructs|copyright + |default|defaultvalue|define|deprecated|desc|description|dict|emits|enum|event|example|exception + |exports?|extends|extension(?:_?for)?|external|externs|file|fileoverview|final|fires|for|func + |function|generator|global|hideconstructor|host|ignore|implements|implicitCast|inherit[Dd]oc + |inner|instance|interface|internal|kind|lends|license|listens|main|member|memberof!?|method + |mixes|mixins?|modifies|module|name|namespace|noalias|nocollapse|nocompile|nosideeffects + |override|overview|package|param|polymer(?:Behavior)?|preserve|private|prop|property|protected + |public|read[Oo]nly|record|require[ds]|returns?|see|since|static|struct|submodule|summary + |suppress|template|this|throws|todo|tutorial|type|typedef|unrestricted|uses|var|variation + |version|virtual|writeOnce|yields?) + \b + captures: + '1': { name: punctuation.definition.block.tag.jsdoc } + - include: '#inline-tags' + # any tag + - match: ((@)(?:{{identifier}}))(?=\s+) + captures: + '1': { name: storage.type.class.jsdoc } + '2': { name: punctuation.definition.block.tag.jsdoc } + + brackets: + # Balanced brackets (square or curly) + patterns: + - begin: '{' + end: '}|(?=\*/)' + patterns: + - include: '#brackets' + - begin: '\[' + end: '\]|(?=\*/)' + patterns: + - include: '#brackets' + + inline-tags: + patterns: + # Description preceding {@inline tag} + - name: constant.other.description.jsdoc + match: (\[)[^\]]+(\])(?={@(?:link|linkcode|linkplain|tutorial)) + captures: + '1': { name: punctuation.definition.bracket.square.begin.jsdoc } + '2': { name: punctuation.definition.bracket.square.end.jsdoc } + # {@link|@tutorial …} + - name: entity.name.type.instance.jsdoc + begin: ({)((@)(?:link(?:code|plain)?|tutorial))\s* + beginCaptures: + '1': { name: punctuation.definition.bracket.curly.begin.jsdoc } + '2': { name: storage.type.class.jsdoc } + '3': { name: punctuation.definition.inline.tag.jsdoc } + end: '}|(?=\*/)' + endCaptures: + '0': { name: punctuation.definition.bracket.curly.end.jsdoc } + patterns: + - match: \G((?=https?://)(?:[^|}\s*]|\*[/])+)(\|)? + captures: + '1': { name: variable.other.link.underline.jsdoc } + '2': { name: punctuation.separator.pipe.jsdoc } + - match: \G((?:[^{}@\s|*]|\*[^/])+)(\|)? + captures: + '1': { name: variable.other.description.jsdoc } + '2': { name: punctuation.separator.pipe.jsdoc } + + jsdoctype: + # {type} + patterns: + # {unclosed + - name: invalid.illegal.type.jsdoc + match: \G{(?:[^}*]|\*[^/}])+$ + - contentName: entity.name.type.instance.jsdoc + begin: \G({) + beginCaptures: + '0': { name: entity.name.type.instance.jsdoc } + '1': { name: punctuation.definition.bracket.curly.begin.jsdoc } + end: ((}))\s*|(?=\*/) + endCaptures: + '1': { name: entity.name.type.instance.jsdoc } + '2': { name: punctuation.definition.bracket.curly.end.jsdoc } + patterns: + - include: '#brackets' ... diff --git a/TypeScript.YAML-tmTheme b/TypeScript.YAML-tmTheme new file mode 100644 index 00000000..899be8eb --- /dev/null +++ b/TypeScript.YAML-tmTheme @@ -0,0 +1,74 @@ +# VS theme settings for TypeScript + +--- +name: TypeScript +uuid: 91489F9C-F403-4CF0-993D-EAAF9149E40E + +settings: +- scope: storage.modifier, storage.type, keyword.other, keyword.operator.expression, keyword.operator.new, keyword.generator.asterisk, punctuation.definition.template-expression + settings: { vsclassificationtype: keyword } +- scope: constant.language, variable.language + settings: { vsclassificationtype: keyword } +- scope: keyword.control, keyword.operator.expression.delete, keyword.other.using, keyword.other.operator, entity.name.operator + settings: { vsclassificationtype: keyword - control } +- scope: support.class, support.type, entity.name.type, entity.name.namespace, entity.other.attribute, entity.name.scope-resolution, entity.name.class + settings: { vsclassificationtype: type } + +- scope: string, punctuation.definition.string, constant.character + settings: { vsclassificationtype: string } +- scope: keyword.control.anchor.regexp, keyword.other.back-reference.regexp, keyword.operator.quantifier.regexp, keyword.operator.or.regexp, keyword.operator.negation.regexp, punctuation.definition.group.regexp, punctuation.definition.group.assertion.regexp, meta.assertion.look-ahead.regexp, meta.assertion.negative-look-ahead.regexp, punctuation.definition.group.capture.regexp, punctuation.definition.character-class.regexp, constant.other.character-class.range.regexp + settings: { vsclassificationtype: string } + +- scope: constant.numeric, meta.delimiter.decimal.period.ts, constant.language.nan.ts, constant.language.infinity.ts + settings: { vsclassificationtype: number } + +- scope: keyword.operator, storage.type.function.arrow.ts + settings: { vsclassificationtype: operator } + +- scope: meta.brace.angle.ts, meta.brace.round.ts, meta.brace.square.ts, punctuation, constant.language.import-export-all.ts, meta.delimiter.object.comma.ts + settings: { vsclassificationtype: punctuation } + +- scope: comment, comment.block.ts, comment.line.double-slash.ts, punctuation.definition.comment.ts + settings: { vsclassificationtype: comment } +- scope: comment.block.documentation.ts, other.meta.jsdoc, other.description.jsdoc + settings: { vsclassificationtype: comment } +- scope: entity.name.type.instance.jsdoc + settings: { vsclassificationtype: identifier } + +- scope: entity.name.type.class.ts + settings: { vsclassificationtype: class name } + +- scope: entity.name.type.module.ts + settings: { vsclassificationtype: module name } + +- scope: entity.name.type.enum.ts + settings: { vsclassificationtype: enum name } + +- scope: meta.template.expression.ts, entity.other.inherited-class.ts + settings: { vsclassificationtype: identifier } +- scope: variable, meta.definition.variable.name, support.variable, entity.name.variable, constant.other.placeholder + settings: { vsclassificationtype: local name } +- scope: entity.name.function, support.function, support.constant.handlebars, source.powershell variable.other.member, entity.name.operator.custom-literal + settings: { vsclassificationtype: method name } + +- scope: variable.language.arguments.ts, support.type.object + settings: { vsclassificationtype: identifier } + +- scope: entity.name.tag.inline, entity.name.tag.directive + settings: { vsclassificationtype: HTML Element Name } + +- scope: entity.other.attribute-name + settings: { vsclassificationtype: HTML Attribute Name } + +- scope: meta.tag string.quoted, meta.tag string.quoted punctuation.definition.string, meta.tag string.quoted + settings: { vsclassificationtype: string } + +- scope: meta.object-literal.key + settings: { vsclassificationtype: parameter name } + +- scope: constant.character.escape + settings: { vsclassificationtype: string - escape character } + +- scope: entity.name.label + settings: { vsclassificationtype: label name } +... diff --git a/TypeScript.tmLanguage b/TypeScript.tmLanguage index 88cda044..4d91f6ad 100644 --- a/TypeScript.tmLanguage +++ b/TypeScript.tmLanguage @@ -1,1996 +1,9858 @@ - - fileTypes - - ts - - name - TypeScript - patterns - - - include - #expression - - - repository - - access-modifier - - match - \b(public|protected|private)\b - name - storage.modifier.ts - - arithmetic-operator - - match - \*|/|\-\-|\-|\+\+|\+|% - name - keyword.operator.arithmetic.ts - - array-literal - - begin - \[ - beginCaptures - - 0 - - name - meta.brace.square.ts - - - end - \] - endCaptures - - 0 - - name - meta.brace.square.ts - - - name - meta.array.literal.ts - patterns - - - include - #expression - - - - assignment-operator - - match - <<=|>>>=|>>=|\*=|(?<!\()/=|%=|\+=|\-=|&=|\^= - name - keyword.operator.assignment.ts - - await-modifier - - match - \bawait\b - name - storage.modifier.ts - - block - - begin - \{ - beginCaptures - - 0 - - name - meta.brace.curly.ts - - - end - \} - endCaptures - - 0 - - name - meta.brace.curly.ts - - - name - meta.block.ts - patterns - - - include - #object-member - - - include - #expression - - - - boolean-literal - - match - \b(false|true)\b - name - constant.language.boolean.ts - - case-clause - - begin - (?<!\.)\b(case|default(?=:))\b - beginCaptures - - 1 - - name - keyword.control.ts - - - end - : - name - case-clause.expr.ts - patterns - - - include - #expression-type - - - - cast - - begin - (?:(?<=return|throw|yield|await|[=(,:>]))\s*(<)(?!<?\=) - beginCaptures - - 1 - - name - meta.brace.angle.ts - - - end - > - endCaptures - - 0 - - name - meta.brace.angle.ts - - - name - cast.expr.ts - patterns - - - include - #type - - - - comment - - name - comment.ts - patterns - - - include - #comment-block-doc - - - include - #comment-block - - - include - #comment-line - - - - comment-block - - begin - /\* - end - \*/ - name - comment.block.ts - - comment-block-doc - - begin - /\*\*(?!/) - end - \*/ - name - comment.block.documentation.ts - - comment-line - - match - (//).*$\n? - name - comment.line.ts - - control-statement - - match - (?<!\.)\b(break|catch|continue|debugger|declare|do|else|finally|for|if|return|switch|throw|try|while|with|super|case|default|yield)\b - name - keyword.control.ts - - decl-block - - begin - \{ - beginCaptures - - 0 - - name - meta.brace.curly.ts - - - end - \} - endCaptures - - 0 - - name - meta.brace.curly.ts - - - name - meta.decl.block.ts - patterns - - - include - #expression - - - - declaration - - name - meta.declaration.ts - patterns - - - include - #function-declaration - - - include - #object-declaration - - - include - #type-declaration - - - include - #enum-declaration - - - - enum-declaration - - captures - - 1 - - name - storage.modifier.ts - - 2 - - name - storage.type.ts - - 3 - - name - entity.name.class.ts - - - match - (?:\b(const)\s+)?\b(enum)\s+([a-zA-Z_$][\w$]*) - name - meta.enum.declaration.ts - - expression - - name - meta.expression.ts - patterns - - - include - #for-in-simple - - - include - #string - - - include - #regex - - - include - #template - - - include - #comment - - - include - #literal - - - include - #paren-expression - - - include - #var-expr - - - include - #declaration - - - include - #cast - - - include - #new-expr - - - include - #switch-statement - - - include - #block - - - include - #import-operator - - - include - #expression-operator - - - include - #imply-operator - - - include - #relational-operator - - - include - #arithmetic-operator - - - include - #logic-operator - - - include - #assignment-operator - - - include - #storage-keyword - - - include - #type-primitive - - - include - #function-call - - - include - #case-clause - - - include - #control-statement - - - - expression-operator - - match - \b(delete|in|instanceof|new|typeof|as|is|of)\b - name - keyword.others.ts - - expression-type - - name - meta.expression.ts - patterns - - - include - #string - - - include - #regex - - - include - #template - - - include - #comment - - - include - #literal - - - include - #paren-expression - - - include - #ternary-expression - - - include - #import-operator - - - include - #expression-operator - - - include - #imply-operator - - - include - #relational-operator - - - include - #arithmetic-operator - - - include - #logic-operator - - - include - #assignment-operator - - - include - #type-primitive - - - include - #function-call - - - - field-declaration - - begin - (?<!\()\s*((?:\b[a-zA-Z_$][\w$]*)|(?:\'[^']*\')|(?:\"[^"]*\"))\s*(\?\s*)?(?=(=|:)) - beginCaptures - - 1 - - name - variable.ts - - 2 - - name - keyword.others.ts - - - end - (?=\}|;|,|$)|(?<=\}) - name - meta.field.declaration.ts - patterns - - - include - #expression - - - - for-in-simple - - captures - - 1 - - name - storage.type.ts - - 3 - - name - keyword.others.ts - - - match - (?<=\()\s*\b(var|let|const)\s+([a-zA-Z_$][\w$]*)\s+(in|of)\b - name - forin.expr.ts - - function-call - - name - functioncall.expr.ts - patterns - - - include - #await-modifier - - - include - #type-parameters - - - include - #paren-expression - - - - function-declaration - - begin - \b(?:(export)\s+)?(?:(async)\s+)?(function\b)(?:\s+([a-zA-Z_$][\w$]*))?\s* - beginCaptures - - 1 - - name - storage.type.ts - - 2 - - name - storage.modifier.ts - - 3 - - name - storage.type.function.ts - - 4 - - name - entity.name.function.ts - - - end - (?=;|\})|(?<=\}) - name - meta.function.ts - patterns - - - include - #comment - - - include - #type-parameters - - - include - #function-type-parameters - - - include - #return-type - - - include - #function-overload-declaration - - - include - #decl-block - - - - function-overload-declaration - - captures - - 1 - - name - storage.type.ts - - 2 - - name - storage.type.function.ts - - 3 - - name - entity.name.function.ts - - - match - \b(?:(export)\s+)?(function\b)(?:\s+([a-zA-Z_$][\w$]*))?\s* - name - meta.function.overload.ts - - function-type-parameters - - begin - \( - beginCaptures - - 0 - - name - meta.brace.round.ts - - - end - \) - endCaptures - - 0 - - name - meta.brace.round.ts - - - name - meta.function.type.parameter.ts - patterns - - - include - #comment - - - include - #parameter-name - - - include - #type-annotation - - - include - #variable-initializer - - - - imply-operator - - match - => - name - keyword.operator.ts - - import-operator - - match - \b(import|from)\b - name - keyword.control.import.include.ts - - indexer-declaration - - begin - \[ - beginCaptures - - 0 - - name - meta.brace.square.ts - - - end - (\])\s*(\?\s*)?|$ - endCaptures - - 1 - - name - meta.brace.square.ts - - 2 - - name - keyword.others.ts - - - name - meta.indexer.declaration.ts - patterns - - - include - #type-annotation - - - include - #indexer-parameter - - - include - #expression - - - - indexer-parameter - - captures - - 1 - - name - variable.parameter.ts - - - match - ([a-zA-Z_$][\w$]*)(?=\:) - name - meta.indexer.parameter.ts - - literal - - name - literal.ts - patterns - - - include - #numeric-literal - - - include - #boolean-literal - - - include - #null-literal - - - include - #undefined-literal - - - include - #array-literal - - - include - #this-literal - - - - logic-operator - - match - \!|&&|&|~|\^|\|\||\| - name - keyword.operator.arithmetic.ts - - method-declaration - - begin - \b(?:(abstract)\s+)?\b(?:(public|private|protected)\s+)?\b(?:(async)\s+)?(?:(get|set)\s+)?(?:(new)|(?:\b(constructor)\b)|(?:([a-zA-Z_$][\.\w$]*)\s*(\??)))?\s*(?=\(|\<) - beginCaptures - - 1 - - name - storage.modifier.ts - - 2 - - name - storage.modifier.ts - - 3 - - name - storage.modifier.ts - - 4 - - name - storage.type.property.ts - - 5 - - name - keyword.operator.ts - - 6 - - name - storage.type.ts - - 7 - - name - entity.name.function.ts - - 8 - - name - keyword.operator.ts - - - end - (?=\}|;|,)|(?<=\}) - name - meta.method.declaration.ts - patterns - - - include - #comment - - - include - #type-parameters - - - include - #function-type-parameters - - - include - #type-annotation - - - include - #method-overload-declaration - - - include - #decl-block - - - - method-overload-declaration - - captures - - 1 - - name - storage.modifier.ts - - 2 - - name - storage.modifier.ts - - 3 - - name - storage.modifier.ts - - 4 - - name - storage.type.property.ts - - 5 - - name - keyword.operator.ts - - 6 - - name - storage.type.ts - - 7 - - name - entity.name.function.ts - - 8 - - name - keyword.operator.ts - - - match - \b(?:(abstract)\s+)?\b(?:(public|private|protected)\s+)?\b(?:(async)\s+)?(?:(get|set)\s+)?(?:(new)|(?:\b(constructor)\b)|(?:([a-zA-Z_$][\.\w$]*)\s*(\??)))?\s*(?=\(|\<) - name - meta.method.overload.declaration.ts - - new-expr - - begin - \b(new)\b - beginCaptures - - 1 - - name - keyword.others.ts - - - end - (?=[(;]|$) - name - new.expr.ts - patterns - - - include - #type - - - include - #comment - - - - null-literal - - match - \b(null)\b - name - constant.language.null.ts - - numeric-literal - - match - \b(?<=[^$])((0(x|X)[0-9a-fA-F]+)|(0(o|O)[0-7]+)|(0(b|B)(0|1)+)|(([0-9]+(\.[0-9]+)?))([eE]([+-]?)[0-9]+(\.[0-9]+)?)?)\b - name - constant.numeric.ts - - object-body - - begin - \{ - beginCaptures - - 0 - - name - meta.brace.curly.ts - - - end - \} - endCaptures - - 0 - - name - meta.brace.curly.ts - - - name - meta.object.body.ts - patterns - - - include - #string - - - include - #comment - - - include - #field-declaration - - - include - #method-declaration - - - include - #indexer-declaration - - - include - #type-annotation - - - include - #variable-initializer - - - include - #access-modifier - - - include - #static-modifier - - - include - #property-accessor - - - - object-declaration - - begin - \b(?:(export)\s+)?\b(?:(abstract)\s+)?\b(?<!\.)(class|interface)\b - beginCaptures - - 1 - - name - storage.type.ts - - 2 - - name - storage.modifier.ts - - 3 - - name - storage.type.ts - - - end - (?<=\}) - endCaptures - - 1 - - name - brace.curly.ts - - - name - meta.declaration.object.ts - patterns - - - include - #comment - - - include - #object-heritage - - - include - #object-name - - - include - #type-parameters - - - include - #object-body - - - - object-heritage - - begin - (?:\b(extends|implements)\b) - beginCaptures - - 1 - - name - keyword.other.ts - - - end - (?=\{) - endCaptures - - 1 - - name - brace.curly.ts - - - name - meta.object.heritage.ts - patterns - - - include - #comment - - - include - #object-heritage - - - include - #type-parameters - - - include - #object-heritage-type - - - - object-heritage-type - - captures - - 1 - - name - support.type.ts - - - match - (?:\b([a-zA-Z_$][\w$]*)\b) - name - meta.object.heritage.parent.ts - - object-member - - begin - [a-zA-Z_$][\w$]*\s*: - end - (?=,|\}) - name - meta.object.member.ts - patterns - - - include - #expression - - - - object-name - - captures - - 0 - - name - entity.name.class.ts - - - match - [a-zA-Z_$][\w$]* - name - meta.object.name.ts - - parameter-name - - captures - - 1 - - name - storage.modifier.ts - - 2 - - name - keyword.others.ts - - 3 - - name - variable.parameter.ts - - 4 - - name - keyword.others.ts - - - match - (?:\s*\b(public|private|protected)\b\s+)?(\.\.\.)?\s*([a-zA-Z_$][\w$]*)\s*(\??) - name - parameter.name.ts - - paren-expression - - begin - \( - beginCaptures - - 0 - - name - meta.brace.paren.ts - - - end - \) - endCaptures - - 0 - - name - meta.brace.paren.ts - - - patterns - - - include - #expression - - - - property-accessor - - match - \b(get|set)\b - name - storage.type.property.ts - - qstring-double - - begin - " - end - "|(?:[^\\\n]$) - name - string.double.ts - patterns - - - include - #string-character-escape - - - - qstring-single - - begin - ' - end - \'|(?:[^\\\n]$) - name - string.single.ts - patterns - - - include - #string-character-escape - - - - regex - - begin - (?<=[=(:,\[]|^|return|&&|\|\||!)\s*(/)(?![/*+{}?]) - end - $|(/)[igm]* - name - string.regex.ts - patterns - - - match - \\. - name - constant.character.escape.ts - - - match - \[(\\\]|[^\]])*\] - name - constant.character.class.ts - - - - relational-operator - - match - ===|!==|==|!=|<=|>=|<>|=|<|> - name - keyword.operator.comparison.ts - - return-type - - begin - (?<=\))\s*: - end - (?=$)|(?=\{|;|//) - name - meta.return.type.ts - patterns - - - include - #type - - - - static-modifier - - match - \b(static)\b - name - keyword.other.ts - - storage-keyword - - match - \b(var|let|function|const|module|namespace|void|export)\b - name - storage.type.ts - - string - - name - string.ts - patterns - - - include - #qstring-single - - - include - #qstring-double - - - - string-character-escape - - match - \\(x\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$) - name - constant.character.escape - - switch-block - - begin - { - end - (?=\}) - name - switch-block.expr.ts - patterns - - - include - #expression - - - - switch-expression - - begin - \b(switch)\b\s*\( - beginCaptures - - 1 - - name - keyword.control.ts - - - end - \) - name - switch-expression.expr.ts - patterns - - - include - #expression - - - - switch-statement - - begin - (?=\bswitch\b\s*\() - end - } - name - switch-statement.expr.ts - patterns - - - include - #switch-expression - - - include - #switch-block - - - - template - - begin - ` - beginCaptures - - 0 - - name - string.template.ts - - - end - ` - endCaptures - - 0 - - name - string.template.ts - - - name - meta.template.ts - patterns - - - include - #template-substitution-element - - - include - #template-string-contents - - - - template-string-contents - - begin - .*? - end - (?=(\$\{|`)) - name - string.template.ts - patterns - - - include - #string-character-escape - - - - template-substitution-element - - begin - \$\{ - beginCaptures - - 0 - - name - keyword.others.ts - - - end - \} - endCaptures - - 0 - - name - keyword.others.ts - - - name - template.element.ts - patterns - - - include - #expression - - - - ternary-expression - - begin - (?=\?) - end - (?=$|[;,]) - patterns - - - include - #ternary-operator - - - include - #expression-type - - - - ternary-operator - - begin - (\?) - end - (:) - patterns - - - include - #expression-type - - - - this-literal - - match - \b(this)\b - name - constant.language.this.ts - - type - - name - meta.type.ts - patterns - - - include - #type-primitive - - - include - #type-parameters - - - include - #type-tuple - - - include - #type-object - - - include - #type-operator - - - include - #type-paren-or-function-type-parameters - - - include - #type-function-return-type - - - include - #type-name - - - - type-annotation - - begin - : - end - (?=$|[,);\}\]]|//)|(?==[^>])|(?<=[\}>\]\)]|[a-zA-Z_$])\s*(?=\{) - name - meta.type.annotation.ts - patterns - - - include - #expression-operator - - - include - #type - - - include - #string - - - include - #comment - - - - type-declaration - - begin - \b(type)\b\s+([a-zA-Z_$][\w$]*)\s* - beginCaptures - - 1 - - name - keyword.other.ts - - 2 - - name - entity.name.class.ts - - - end - (?=$|[,);>]|var|type|function|class|interface) - name - meta.type.declaration.ts - patterns - - - include - #type-parameters - - - include - #type - - - match - =\s* - name - keyword.operator.comparison.ts - - - - type-function-return-type - - begin - => - beginCaptures - - 0 - - name - keyword.operator.ts - - - end - (?=\s*[,\)\{=;>]|//|$) - name - meta.type.function.return.ts - patterns - - - include - #type - - - - type-name - - captures - - 1 - - name - entity.name.type.ts - - - match - [a-zA-Z_$][.\w$]* - name - meta.type.name.ts - - type-object - - begin - \{ - beginCaptures - - 0 - - name - meta.brace.curly.ts - - - end - \} - endCaptures - - 0 - - name - meta.brace.curly.ts - - - name - meta.object.type.ts - patterns - - - include - #comment - - - include - #field-declaration - - - include - #method-declaration - - - include - #indexer-declaration - - - include - #type-annotation - - - - type-operator - - match - [.|] - name - keyword.operator.type.ts - - type-parameters - - begin - ([a-zA-Z_$][\w$]*)?(<) - beginCaptures - - 1 - - name - entity.name.type.ts - - 2 - - name - meta.brace.angle.ts - - - end - (?=$)|(>) - endCaptures - - 2 - - name - meta.brace.angle.ts - - - name - meta.type.parameters.ts - patterns - - - match - \b(extends)\b - name - keyword.other.ts - - - include - #comment - - - include - #type - - - - type-paren-or-function-type-parameters - - begin - (?:\b(new)\b)?\s*\( - beginCaptures - - 1 - - name - keyword.control.ts - - - end - \) - name - meta.type.paren.cover.ts - patterns - - - include - #comment - - - include - #type - - - include - #function-type-parameters - - - - type-primitive - - captures - - 1 - - name - support.type.ts - - - match - \b(string|number|boolean|symbol|any|void)\b - name - meta.type.primitive.ts - - type-tuple - - begin - \[ - beginCaptures - - 0 - - name - meta.brace.square.ts - - - end - \] - endCaptures - - 0 - - name - meta.brace.square.ts - - - name - meta.type.tuple.ts - patterns - - - include - #type - - - include - #comment - - - - undefined-literal - - match - \b(undefined)\b - name - constant.language.ts - - var-expr - - begin - (?<!\()\s*\b(var|let|const(?!\s+enum))\b - beginCaptures - - 1 - - name - storage.type.ts - - - end - (?=$|;) - name - meta.var.expr.ts - patterns - - - include - #var-single-variable - - - include - #comment - - - - var-single-variable - - begin - \b([a-zA-Z_$][\w$]*)\s*(=?) - beginCaptures - - 1 - - name - variable.ts - - - end - (?=$|[;,]) - name - meta.var-single-variable.expr.ts - patterns - - - include - #ternary-expression - - - include - #type-annotation - - - include - #string - - - include - #comment - - - include - #expression - - - - variable-initializer - - begin - (=) - beginCaptures - - 1 - - name - keyword.operator.comparison.ts - - - end - (?=$|[,);=]) - patterns - - - include - #expression - - - - - scopeName - source.ts - uuid - ef98eb90-bf9b-11e4-bb52-0800200c9a66 - - + + name + TypeScript + scopeName + source.ts + fileTypes + + ts + + uuid + ef98eb90-bf9b-11e4-bb52-0800200c9a66 + patterns + + + include + #directives + + + include + #statements + + + include + #shebang + + + repository + + shebang + + name + comment.line.shebang.ts + match + \A(#!).*(?=$) + captures + + 1 + + name + punctuation.definition.comment.ts + + + + statements + + patterns + + + include + #declaration + + + include + #control-statement + + + include + #after-operator-block-as-object-literal + + + include + #decl-block + + + include + #label + + + include + #expression + + + include + #punctuation-semicolon + + + include + #string + + + include + #comment + + + + declaration + + patterns + + + include + #decorator + + + include + #var-expr + + + include + #function-declaration + + + include + #class-declaration + + + include + #interface-declaration + + + include + #enum-declaration + + + include + #namespace-declaration + + + include + #type-alias-declaration + + + include + #import-equals-declaration + + + include + #import-declaration + + + include + #export-declaration + + + name + storage.modifier.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(declare|export)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + + control-statement + + patterns + + + include + #switch-statement + + + include + #for-loop + + + name + keyword.control.trycatch.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(catch|finally|throw|try)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(break|continue|goto)\s+([_$[:alpha:]][_$[:alnum:]]*)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + captures + + 1 + + name + keyword.control.loop.ts + + 2 + + name + entity.name.label.ts + + + + + name + keyword.control.loop.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(break|continue|do|goto|while)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(return)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 0 + + name + keyword.control.flow.ts + + + end + (?=[;}]|$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #expression + + + + + name + keyword.control.switch.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default|switch)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + include + #if-statement + + + name + keyword.control.conditional.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(else|if)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.control.with.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(with)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.control.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(package)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.other.debugger.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(debugger)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + + label + + patterns + + + begin + ([_$[:alpha:]][_$[:alnum:]]*)\s*(:)(?=\s*\{) + beginCaptures + + 1 + + name + entity.name.label.ts + + 2 + + name + punctuation.separator.label.ts + + + end + (?<=\}) + patterns + + + include + #decl-block + + + + + match + ([_$[:alpha:]][_$[:alnum:]]*)\s*(:) + captures + + 1 + + name + entity.name.label.ts + + 2 + + name + punctuation.separator.label.ts + + + + + + expression + + patterns + + + include + #expressionWithoutIdentifiers + + + include + #identifiers + + + include + #expressionPunctuations + + + + expressionWithoutIdentifiers + + patterns + + + include + #string + + + include + #regex + + + include + #comment + + + include + #function-expression + + + include + #class-expression + + + include + #arrow-function + + + include + #paren-expression-possibly-arrow + + + include + #cast + + + include + #ternary-expression + + + include + #new-expr + + + include + #instanceof-expr + + + include + #object-literal + + + include + #expression-operators + + + include + #function-call + + + include + #literal + + + include + #support-objects + + + include + #paren-expression + + + + expressionPunctuations + + patterns + + + include + #punctuation-comma + + + include + #punctuation-accessor + + + + decorator + + name + meta.decorator.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))\@ + beginCaptures + + 0 + + name + punctuation.decorator.ts + + + end + (?=\s) + patterns + + + include + #expression + + + + var-expr + + patterns + + + name + meta.var.expr.ts + begin + (?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) + end + (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=^|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|((?<!^let|[^\._$[:alnum:]]let|^var|[^\._$[:alnum:]]var)(?=\s*$))) + patterns + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s* + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.type.ts + + + end + (?=\S) + + + include + #destructuring-variable + + + include + #var-single-variable + + + include + #variable-initializer + + + include + #comment + + + begin + (,)\s*(?=$|\/\/) + beginCaptures + + 1 + + name + punctuation.separator.comma.ts + + + end + (?<!,)(((?==|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$))) + patterns + + + include + #single-line-comment-consuming-line-ending + + + include + #comment + + + include + #destructuring-variable + + + include + #var-single-variable + + + include + #punctuation-comma + + + + + include + #punctuation-comma + + + + + name + meta.var.expr.ts + begin + (?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.type.ts + + + end + (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=^|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|((?<!^const|[^\._$[:alnum:]]const)(?=\s*$))) + patterns + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s* + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.type.ts + + + end + (?=\S) + + + include + #destructuring-const + + + include + #var-single-const + + + include + #variable-initializer + + + include + #comment + + + begin + (,)\s*(?=$|\/\/) + beginCaptures + + 1 + + name + punctuation.separator.comma.ts + + + end + (?<!,)(((?==|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$))) + patterns + + + include + #single-line-comment-consuming-line-ending + + + include + #comment + + + include + #destructuring-const + + + include + #var-single-const + + + include + #punctuation-comma + + + + + include + #punctuation-comma + + + + + name + meta.var.expr.ts + begin + (?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b((?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.type.ts + + + end + (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b((?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|((?<!^using|[^\._$[:alnum:]]using|^await\s+using|[^\._$[:alnum:]]await\s+using)(?=\s*$))) + patterns + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b((?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s* + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.type.ts + + + end + (?=\S) + + + include + #var-single-const + + + include + #variable-initializer + + + include + #comment + + + begin + (,)\s*((?!\S)|(?=\/\/)) + beginCaptures + + 1 + + name + punctuation.separator.comma.ts + + + end + (?<!,)(((?==|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$))) + patterns + + + include + #single-line-comment-consuming-line-ending + + + include + #comment + + + include + #var-single-const + + + include + #punctuation-comma + + + + + include + #punctuation-comma + + + + + + var-single-variable + + patterns + + + name + meta.var-single-variable.expr.ts + begin + (?x)([_$[:alpha:]][_$[:alnum:]]*)(\!)?(?=\s* +# function assignment | +(=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | + +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +)) | +# typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => +(:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) +)) | +(:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) | +(:\s*((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | +(:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | + +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +))) + beginCaptures + + 1 + + name + meta.definition.variable.ts entity.name.function.ts + + 2 + + name + keyword.operator.definiteassignment.ts + + + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))) + patterns + + + include + #var-single-variable-type-annotation + + + + + name + meta.var-single-variable.expr.ts + begin + ([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])(\!)? + beginCaptures + + 1 + + name + meta.definition.variable.ts variable.other.constant.ts + + 2 + + name + keyword.operator.definiteassignment.ts + + + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))) + patterns + + + include + #var-single-variable-type-annotation + + + + + name + meta.var-single-variable.expr.ts + begin + ([_$[:alpha:]][_$[:alnum:]]*)(\!)? + beginCaptures + + 1 + + name + meta.definition.variable.ts variable.other.readwrite.ts + + 2 + + name + keyword.operator.definiteassignment.ts + + + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))) + patterns + + + include + #var-single-variable-type-annotation + + + + + + var-single-const + + patterns + + + name + meta.var-single-variable.expr.ts + begin + (?x)([_$[:alpha:]][_$[:alnum:]]*)(?=\s* +# function assignment | +(=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | + +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +)) | +# typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => +(:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) +)) | +(:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) | +(:\s*((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | +(:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | + +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +))) + beginCaptures + + 1 + + name + meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + + + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))) + patterns + + + include + #var-single-variable-type-annotation + + + + + name + meta.var-single-variable.expr.ts + begin + ([_$[:alpha:]][_$[:alnum:]]*) + beginCaptures + + 1 + + name + meta.definition.variable.ts variable.other.constant.ts + + + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))) + patterns + + + include + #var-single-variable-type-annotation + + + + + + var-single-variable-type-annotation + + patterns + + + include + #type-annotation + + + include + #string + + + include + #comment + + + + destructuring-variable + + patterns + + + name + meta.object-binding-pattern-variable.ts + begin + (?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\{) + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)) + patterns + + + include + #object-binding-pattern + + + include + #type-annotation + + + include + #comment + + + + + name + meta.array-binding-pattern-variable.ts + begin + (?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\[) + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)) + patterns + + + include + #array-binding-pattern + + + include + #type-annotation + + + include + #comment + + + + + + destructuring-const + + patterns + + + name + meta.object-binding-pattern-variable.ts + begin + (?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\{) + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)) + patterns + + + include + #object-binding-pattern-const + + + include + #type-annotation + + + include + #comment + + + + + name + meta.array-binding-pattern-variable.ts + begin + (?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\[) + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)) + patterns + + + include + #array-binding-pattern-const + + + include + #type-annotation + + + include + #comment + + + + + + object-binding-element + + patterns + + + include + #comment + + + begin + (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:)) + end + (?=,|\}) + patterns + + + include + #object-binding-element-propertyName + + + include + #binding-element + + + + + include + #object-binding-pattern + + + include + #destructuring-variable-rest + + + include + #variable-initializer + + + include + #punctuation-comma + + + + object-binding-element-const + + patterns + + + include + #comment + + + begin + (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:)) + end + (?=,|\}) + patterns + + + include + #object-binding-element-propertyName + + + include + #binding-element-const + + + + + include + #object-binding-pattern-const + + + include + #destructuring-variable-rest-const + + + include + #variable-initializer + + + include + #punctuation-comma + + + + object-binding-element-propertyName + + begin + (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:)) + end + (:) + endCaptures + + 0 + + name + punctuation.destructuring.ts + + + patterns + + + include + #string + + + include + #array-literal + + + include + #numeric-literal + + + name + variable.object.property.ts + match + ([_$[:alpha:]][_$[:alnum:]]*) + + + + binding-element + + patterns + + + include + #comment + + + include + #string + + + include + #numeric-literal + + + include + #regex + + + include + #object-binding-pattern + + + include + #array-binding-pattern + + + include + #destructuring-variable-rest + + + include + #variable-initializer + + + + binding-element-const + + patterns + + + include + #comment + + + include + #string + + + include + #numeric-literal + + + include + #regex + + + include + #object-binding-pattern-const + + + include + #array-binding-pattern-const + + + include + #destructuring-variable-rest-const + + + include + #variable-initializer + + + + destructuring-variable-rest + + match + (?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + keyword.operator.rest.ts + + 2 + + name + meta.definition.variable.ts variable.other.readwrite.ts + + + + destructuring-variable-rest-const + + match + (?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + keyword.operator.rest.ts + + 2 + + name + meta.definition.variable.ts variable.other.constant.ts + + + + object-binding-pattern + + begin + (?:(\.\.\.)\s*)?(\{) + beginCaptures + + 1 + + name + keyword.operator.rest.ts + + 2 + + name + punctuation.definition.binding-pattern.object.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.object.ts + + + patterns + + + include + #object-binding-element + + + + object-binding-pattern-const + + begin + (?:(\.\.\.)\s*)?(\{) + beginCaptures + + 1 + + name + keyword.operator.rest.ts + + 2 + + name + punctuation.definition.binding-pattern.object.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.object.ts + + + patterns + + + include + #object-binding-element-const + + + + array-binding-pattern + + begin + (?:(\.\.\.)\s*)?(\[) + beginCaptures + + 1 + + name + keyword.operator.rest.ts + + 2 + + name + punctuation.definition.binding-pattern.array.ts + + + end + \] + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.array.ts + + + patterns + + + include + #binding-element + + + include + #punctuation-comma + + + + array-binding-pattern-const + + begin + (?:(\.\.\.)\s*)?(\[) + beginCaptures + + 1 + + name + keyword.operator.rest.ts + + 2 + + name + punctuation.definition.binding-pattern.array.ts + + + end + \] + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.array.ts + + + patterns + + + include + #binding-element-const + + + include + #punctuation-comma + + + + parameter-name + + patterns + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|protected|private|readonly)\s+(?=(override|public|protected|private|readonly)\s+) + captures + + 1 + + name + storage.modifier.ts + + + + + match + (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s* +# function assignment | +(=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | + +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +)) | +# typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => +(:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) +)) | +(:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) | +(:\s*((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | +(:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | + +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +))) + captures + + 1 + + name + storage.modifier.ts + + 2 + + name + keyword.operator.rest.ts + + 3 + + name + entity.name.function.ts variable.language.this.ts + + 4 + + name + entity.name.function.ts + + 5 + + name + keyword.operator.optional.ts + + + + + match + (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??) + captures + + 1 + + name + storage.modifier.ts + + 2 + + name + keyword.operator.rest.ts + + 3 + + name + variable.parameter.ts variable.language.this.ts + + 4 + + name + variable.parameter.ts + + 5 + + name + keyword.operator.optional.ts + + + + + + destructuring-parameter + + patterns + + + name + meta.parameter.object-binding-pattern.ts + begin + (?<!=|:)\s*(?:(\.\.\.)\s*)?(\{) + beginCaptures + + 1 + + name + keyword.operator.rest.ts + + 2 + + name + punctuation.definition.binding-pattern.object.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.object.ts + + + patterns + + + include + #parameter-object-binding-element + + + + + name + meta.paramter.array-binding-pattern.ts + begin + (?<!=|:)\s*(?:(\.\.\.)\s*)?(\[) + beginCaptures + + 1 + + name + keyword.operator.rest.ts + + 2 + + name + punctuation.definition.binding-pattern.array.ts + + + end + \] + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.array.ts + + + patterns + + + include + #parameter-binding-element + + + include + #punctuation-comma + + + + + + parameter-object-binding-element + + patterns + + + include + #comment + + + begin + (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:)) + end + (?=,|\}) + patterns + + + include + #object-binding-element-propertyName + + + include + #parameter-binding-element + + + include + #paren-expression + + + + + include + #parameter-object-binding-pattern + + + include + #destructuring-parameter-rest + + + include + #variable-initializer + + + include + #punctuation-comma + + + + parameter-binding-element + + patterns + + + include + #comment + + + include + #string + + + include + #numeric-literal + + + include + #regex + + + include + #parameter-object-binding-pattern + + + include + #parameter-array-binding-pattern + + + include + #destructuring-parameter-rest + + + include + #variable-initializer + + + + destructuring-parameter-rest + + match + (?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + keyword.operator.rest.ts + + 2 + + name + variable.parameter.ts + + + + parameter-object-binding-pattern + + begin + (?:(\.\.\.)\s*)?(\{) + beginCaptures + + 1 + + name + keyword.operator.rest.ts + + 2 + + name + punctuation.definition.binding-pattern.object.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.object.ts + + + patterns + + + include + #parameter-object-binding-element + + + + parameter-array-binding-pattern + + begin + (?:(\.\.\.)\s*)?(\[) + beginCaptures + + 1 + + name + keyword.operator.rest.ts + + 2 + + name + punctuation.definition.binding-pattern.array.ts + + + end + \] + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.array.ts + + + patterns + + + include + #parameter-binding-element + + + include + #punctuation-comma + + + + field-declaration + + name + meta.field.declaration.ts + begin + (?x)(?<!\()(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s+)?(?=\s*((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|(\#?[_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(?:(?:(\?)|(\!))\s*)?(=|:|;|,|\}|$)) + beginCaptures + + 1 + + name + storage.modifier.ts + + + end + (?x)(?=\}|;|,|$|(^(?!\s*((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|(\#?[_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(?:(?:(\?)|(\!))\s*)?(=|:|;|,|$))))|(?<=\}) + patterns + + + include + #variable-initializer + + + include + #type-annotation + + + include + #string + + + include + #array-literal + + + include + #numeric-literal + + + include + #comment + + + match + (?x)(\#?[_$[:alpha:]][_$[:alnum:]]*)(?:(\?)|(\!))?(?=\s*\s* +# function assignment | +(=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | + +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +)) | +# typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => +(:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) +)) | +(:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) | +(:\s*((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | +(:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | + +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +))) + captures + + 1 + + name + meta.definition.property.ts entity.name.function.ts + + 2 + + name + keyword.operator.optional.ts + + 3 + + name + keyword.operator.definiteassignment.ts + + + + + name + meta.definition.property.ts variable.object.property.ts + match + \#?[_$[:alpha:]][_$[:alnum:]]* + + + name + keyword.operator.optional.ts + match + \? + + + name + keyword.operator.definiteassignment.ts + match + \! + + + + variable-initializer + + patterns + + + begin + (?<!=|!)(=)(?!=)(?=\s*\S)(?!\s*.*=>\s*$) + beginCaptures + + 1 + + name + keyword.operator.assignment.ts + + + end + (?=$|^|[,);}\]]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)) + patterns + + + include + #expression + + + + + begin + (?<!=|!)(=)(?!=) + beginCaptures + + 1 + + name + keyword.operator.assignment.ts + + + end + (?=[,);}\]]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))|(?=^\s*$)|(?<![\|\&\+\-\*\/])(?<=\S)(?<!=)(?=\s*$) + patterns + + + include + #expression + + + + + + function-declaration + + name + meta.function.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s* + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.modifier.async.ts + + 4 + + name + storage.type.function.ts + + 5 + + name + keyword.generator.asterisk.ts + + 6 + + name + meta.definition.function.ts entity.name.function.ts + + + end + (?=;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|(?<=\}) + patterns + + + include + #function-name + + + include + #function-body + + + + function-expression + + name + meta.function.expression.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s* + beginCaptures + + 1 + + name + storage.modifier.async.ts + + 2 + + name + storage.type.function.ts + + 3 + + name + keyword.generator.asterisk.ts + + 4 + + name + meta.definition.function.ts entity.name.function.ts + + + end + (?=;)|(?<=\}) + patterns + + + include + #function-name + + + include + #single-line-comment-consuming-line-ending + + + include + #function-body + + + + function-name + + name + meta.definition.function.ts entity.name.function.ts + match + [_$[:alpha:]][_$[:alnum:]]* + + function-body + + patterns + + + include + #comment + + + include + #type-parameters + + + include + #function-parameters + + + include + #return-type + + + include + #type-function-return-type + + + include + #decl-block + + + name + keyword.generator.asterisk.ts + match + \* + + + + method-declaration + + patterns + + + name + meta.method.declaration.ts + begin + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?\s*\b(constructor)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + storage.modifier.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.modifier.ts + + 4 + + name + storage.modifier.async.ts + + 5 + + name + storage.type.ts + + + end + (?=\}|;|,|$)|(?<=\}) + patterns + + + include + #method-declaration-name + + + include + #function-body + + + + + name + meta.method.declaration.ts + begin + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:(?:\s*\b(new)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|(?:(\*)\s*)?)(?=\s*((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + beginCaptures + + 1 + + name + storage.modifier.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.modifier.ts + + 4 + + name + storage.modifier.async.ts + + 5 + + name + keyword.operator.new.ts + + 6 + + name + keyword.generator.asterisk.ts + + + end + (?=\}|;|,|$)|(?<=\}) + patterns + + + include + #method-declaration-name + + + include + #function-body + + + + + name + meta.method.declaration.ts + begin + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=\s*(((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + beginCaptures + + 1 + + name + storage.modifier.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.modifier.ts + + 4 + + name + storage.modifier.async.ts + + 5 + + name + storage.type.property.ts + + 6 + + name + keyword.generator.asterisk.ts + + + end + (?=\}|;|,|$)|(?<=\}) + patterns + + + include + #method-declaration-name + + + include + #function-body + + + + + + object-literal-method-declaration + + name + meta.method.declaration.ts + begin + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=\s*(((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + beginCaptures + + 1 + + name + storage.modifier.async.ts + + 2 + + name + storage.type.property.ts + + 3 + + name + keyword.generator.asterisk.ts + + + end + (?=\}|;|,)|(?<=\}) + patterns + + + include + #method-declaration-name + + + include + #function-body + + + begin + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=\s*(((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + beginCaptures + + 1 + + name + storage.modifier.async.ts + + 2 + + name + storage.type.property.ts + + 3 + + name + keyword.generator.asterisk.ts + + + end + (?=\(|\<) + patterns + + + include + #method-declaration-name + + + + + + method-declaration-name + + begin + (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??)\s*[\(\<]) + end + (?=\(|\<) + patterns + + + include + #string + + + include + #array-literal + + + include + #numeric-literal + + + name + meta.definition.method.ts entity.name.function.ts + match + [_$[:alpha:]][_$[:alnum:]]* + + + name + keyword.operator.optional.ts + match + \? + + + + arrow-function + + patterns + + + name + meta.arrow.ts + match + (?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync)\s+)?([_$[:alpha:]][_$[:alnum:]]*)\s*(?==>) + captures + + 1 + + name + storage.modifier.async.ts + + 2 + + name + variable.parameter.ts + + + + + name + meta.arrow.ts + begin + (?x) (?: + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync) +)? ((?<![})!\]])\s* + (?= + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | + +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + ) +) + beginCaptures + + 1 + + name + storage.modifier.async.ts + + + end + (?==>|\{|(^\s*(export|function|class|interface|let|var|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|const|import|enum|namespace|module|type|abstract|declare)\s+)) + patterns + + + include + #comment + + + include + #type-parameters + + + include + #function-parameters + + + include + #arrow-return-type + + + include + #possibly-arrow-return-type + + + + + name + meta.arrow.ts + begin + => + beginCaptures + + 0 + + name + storage.type.function.arrow.ts + + + end + ((?<=\}|\S)(?<!=>)|((?!\{)(?=\S)))(?!\/[\/\*]) + patterns + + + include + #single-line-comment-consuming-line-ending + + + include + #decl-block + + + include + #expression + + + + + + indexer-declaration + + name + meta.indexer.declaration.ts + begin + (?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s*)?\s*(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s*(?=:) + beginCaptures + + 1 + + name + storage.modifier.ts + + 2 + + name + meta.brace.square.ts + + 3 + + name + variable.parameter.ts + + + end + (\])\s*(\?\s*)?|$ + endCaptures + + 1 + + name + meta.brace.square.ts + + 2 + + name + keyword.operator.optional.ts + + + patterns + + + include + #type-annotation + + + + indexer-mapped-type-declaration + + name + meta.indexer.mappedtype.declaration.ts + begin + (?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))([+-])?(readonly)\s*)?\s*(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s+(in)\s+ + beginCaptures + + 1 + + name + keyword.operator.type.modifier.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + meta.brace.square.ts + + 4 + + name + entity.name.type.ts + + 5 + + name + keyword.operator.expression.in.ts + + + end + (\])([+-])?\s*(\?\s*)?|$ + endCaptures + + 1 + + name + meta.brace.square.ts + + 2 + + name + keyword.operator.type.modifier.ts + + 3 + + name + keyword.operator.optional.ts + + + patterns + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+ + captures + + 1 + + name + keyword.control.as.ts + + + + + include + #type + + + + function-parameters + + name + meta.parameters.ts + begin + \( + beginCaptures + + 0 + + name + punctuation.definition.parameters.begin.ts + + + end + \) + endCaptures + + 0 + + name + punctuation.definition.parameters.end.ts + + + patterns + + + include + #function-parameters-body + + + + function-parameters-body + + patterns + + + include + #comment + + + include + #string + + + include + #decorator + + + include + #destructuring-parameter + + + include + #parameter-name + + + include + #parameter-type-annotation + + + include + #variable-initializer + + + name + punctuation.separator.parameter.ts + match + , + + + + class-declaration + + name + meta.class.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(?:(abstract)\s+)?\b(class)\b(?=\s+|/[/*]) + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.modifier.ts + + 4 + + name + storage.type.class.ts + + + end + (?<=\}) + patterns + + + include + #class-declaration-or-expression-patterns + + + + class-expression + + name + meta.class.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(class)\b(?=\s+|[<{]|\/[\/*]) + beginCaptures + + 1 + + name + storage.modifier.ts + + 2 + + name + storage.type.class.ts + + + end + (?<=\}) + patterns + + + include + #class-declaration-or-expression-patterns + + + + class-declaration-or-expression-patterns + + patterns + + + include + #comment + + + include + #class-or-interface-heritage + + + match + [_$[:alpha:]][_$[:alnum:]]* + captures + + 0 + + name + entity.name.type.class.ts + + + + + include + #type-parameters + + + include + #class-or-interface-body + + + + interface-declaration + + name + meta.interface.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(?:(abstract)\s+)?\b(interface)\b(?=\s+|/[/*]) + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.modifier.ts + + 4 + + name + storage.type.interface.ts + + + end + (?<=\}) + patterns + + + include + #comment + + + include + #class-or-interface-heritage + + + match + [_$[:alpha:]][_$[:alnum:]]* + captures + + 0 + + name + entity.name.type.interface.ts + + + + + include + #type-parameters + + + include + #class-or-interface-body + + + + class-or-interface-heritage + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(extends|implements)\b)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + storage.modifier.ts + + + end + (?=\{) + patterns + + + include + #comment + + + include + #class-or-interface-heritage + + + include + #type-parameters + + + include + #expressionWithoutIdentifiers + + + match + ([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))(?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)*\s*) + captures + + 1 + + name + entity.name.type.module.ts + + 2 + + name + punctuation.accessor.ts + + 3 + + name + punctuation.accessor.optional.ts + + + + + match + ([_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + entity.other.inherited-class.ts + + + + + include + #expressionPunctuations + + + + class-or-interface-body + + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.ts + + + patterns + + + include + #comment + + + include + #decorator + + + begin + (?<=:)\s* + end + (?=\s|[;),}\]:\-\+]|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #expression + + + + + include + #method-declaration + + + include + #indexer-declaration + + + include + #field-declaration + + + include + #string + + + include + #type-annotation + + + include + #variable-initializer + + + include + #access-modifier + + + include + #property-accessor + + + include + #async-modifier + + + include + #after-operator-block-as-object-literal + + + include + #decl-block + + + include + #expression + + + include + #punctuation-comma + + + include + #punctuation-semicolon + + + + access-modifier + + name + storage.modifier.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(abstract|declare|override|public|protected|private|readonly|static)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + property-accessor + + name + storage.type.property.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(accessor|get|set)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + async-modifier + + name + storage.modifier.async.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(async)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + enum-declaration + + name + meta.enum.declaration.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?(?:\b(const)\s+)?\b(enum)\s+([_$[:alpha:]][_$[:alnum:]]*) + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.modifier.ts + + 4 + + name + storage.type.enum.ts + + 5 + + name + entity.name.type.enum.ts + + + end + (?<=\}) + patterns + + + include + #comment + + + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.ts + + + patterns + + + include + #comment + + + begin + ([_$[:alpha:]][_$[:alnum:]]*) + beginCaptures + + 0 + + name + variable.other.enummember.ts + + + end + (?=,|\}|$) + patterns + + + include + #comment + + + include + #variable-initializer + + + + + begin + (?=((\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))) + end + (?=,|\}|$) + patterns + + + include + #string + + + include + #array-literal + + + include + #comment + + + include + #variable-initializer + + + + + include + #punctuation-comma + + + + + + namespace-declaration + + name + meta.namespace.declaration.ts + begin + (?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(namespace|module)\s+(?=[_$[:alpha:]"'`])) + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.type.namespace.ts + + + end + (?<=\})|(?=;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #comment + + + include + #string + + + name + entity.name.type.module.ts + match + ([_$[:alpha:]][_$[:alnum:]]*) + + + include + #punctuation-accessor + + + include + #decl-block + + + + type-alias-declaration + + name + meta.type.declaration.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(type)\b\s+([_$[:alpha:]][_$[:alnum:]]*)\s* + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + storage.type.type.ts + + 4 + + name + entity.name.type.alias.ts + + + end + (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #comment + + + include + #type-parameters + + + begin + (=)\s*(intrinsic)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + keyword.operator.assignment.ts + + 2 + + name + keyword.control.intrinsic.ts + + + end + (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #type + + + + + begin + (=)\s* + beginCaptures + + 1 + + name + keyword.operator.assignment.ts + + + end + (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #type + + + + + + import-equals-declaration + + patterns + + + name + meta.import-equals.external.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(import)(?:\s+(type))?\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(require)\s*(\() + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + keyword.control.import.ts + + 4 + + name + keyword.control.type.ts + + 5 + + name + variable.other.readwrite.alias.ts + + 6 + + name + keyword.operator.assignment.ts + + 7 + + name + keyword.control.require.ts + + 8 + + name + meta.brace.round.ts + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.ts + + + patterns + + + include + #comment + + + include + #string + + + + + name + meta.import-equals.internal.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(import)(?:\s+(type))?\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(?!require\b) + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + keyword.control.import.ts + + 4 + + name + keyword.control.type.ts + + 5 + + name + variable.other.readwrite.alias.ts + + 6 + + name + keyword.operator.assignment.ts + + + end + (?=;|$|^) + patterns + + + include + #single-line-comment-consuming-line-ending + + + include + #comment + + + match + ([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]]))) + captures + + 1 + + name + entity.name.type.module.ts + + 2 + + name + punctuation.accessor.ts + + 3 + + name + punctuation.accessor.optional.ts + + + + + name + variable.other.readwrite.ts + match + ([_$[:alpha:]][_$[:alnum:]]*) + + + + + + import-declaration + + name + meta.import.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(import)(?:\s+(type)(?!\s+from))?(?!\s*[:\(])(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + keyword.control.import.ts + + 4 + + name + keyword.control.type.ts + + + end + (?<!^import|[^\._$[:alnum:]]import)(?=;|$|^) + patterns + + + include + #single-line-comment-consuming-line-ending + + + include + #comment + + + include + #string + + + begin + (?<=^import|[^\._$[:alnum:]]import)(?!\s*["']) + end + \bfrom\b + endCaptures + + 0 + + name + keyword.control.from.ts + + + patterns + + + include + #import-export-declaration + + + + + include + #import-export-declaration + + + + export-declaration + + patterns + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)\s+(as)\s+(namespace)\s+([_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + keyword.control.export.ts + + 2 + + name + keyword.control.as.ts + + 3 + + name + storage.type.namespace.ts + + 4 + + name + entity.name.type.module.ts + + + + + name + meta.export.default.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:\s+(type))?(?:(?:\s*(=))|(?:\s+(default)(?=\s+))) + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + keyword.control.type.ts + + 3 + + name + keyword.operator.assignment.ts + + 4 + + name + keyword.control.default.ts + + + end + (?=$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #interface-declaration + + + include + #expression + + + + + name + meta.export.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:\s+(type))?\b(?!(\$)|(\s*:))((?=\s*[\{*])|((?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s|,))(?!\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))) + beginCaptures + + 1 + + name + keyword.control.export.ts + + 2 + + name + keyword.control.type.ts + + + end + (?=$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #import-export-declaration + + + + + + import-export-declaration + + patterns + + + include + #comment + + + include + #string + + + include + #import-export-block + + + name + keyword.control.from.ts + match + \bfrom\b + + + include + #import-export-assert-clause + + + include + #import-export-clause + + + + import-export-assert-clause + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(with)|(assert))\s*(\{) + beginCaptures + + 1 + + name + keyword.control.with.ts + + 2 + + name + keyword.control.assert.ts + + 3 + + name + punctuation.definition.block.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.ts + + + patterns + + + include + #comment + + + include + #string + + + name + meta.object-literal.key.ts + match + (?:[_$[:alpha:]][_$[:alnum:]]*)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:) + + + name + punctuation.separator.key-value.ts + match + : + + + + import-export-block + + name + meta.block.ts + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.ts + + + patterns + + + include + #import-export-clause + + + + import-export-clause + + patterns + + + include + #comment + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(?:(\btype)\s+)?(?:(\bdefault)|(\*)|(\b[_$[:alpha:]][_$[:alnum:]]*)|((\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))))\s+(as)\s+(?:(default(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|([_$[:alpha:]][_$[:alnum:]]*)|((\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))) + captures + + 1 + + name + keyword.control.type.ts + + 2 + + name + keyword.control.default.ts + + 3 + + name + constant.language.import-export-all.ts + + 4 + + name + variable.other.readwrite.ts + + 5 + + name + string.quoted.alias.ts + + 12 + + name + keyword.control.as.ts + + 13 + + name + keyword.control.default.ts + + 14 + + name + variable.other.readwrite.alias.ts + + 15 + + name + string.quoted.alias.ts + + + + + include + #punctuation-comma + + + name + constant.language.import-export-all.ts + match + \* + + + name + keyword.control.default.ts + match + \b(default)\b + + + match + (?:(\btype)\s+)?(?:([_$[:alpha:]][_$[:alnum:]]*)|((\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))) + captures + + 1 + + name + keyword.control.type.ts + + 2 + + name + variable.other.readwrite.alias.ts + + 3 + + name + string.quoted.alias.ts + + + + + + switch-statement + + name + switch-statement.expr.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bswitch\s*\() + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.ts + + + patterns + + + include + #comment + + + name + switch-expression.expr.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(switch)\s*(\() + beginCaptures + + 1 + + name + keyword.control.switch.ts + + 2 + + name + meta.brace.round.ts + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.ts + + + patterns + + + include + #expression + + + + + name + switch-block.expr.ts + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.ts + + + end + (?=\}) + patterns + + + name + case-clause.expr.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default(?=:))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + keyword.control.switch.ts + + + end + (?=:) + patterns + + + include + #expression + + + + + begin + (:)\s*(\{) + beginCaptures + + 1 + + name + case-clause.expr.ts punctuation.definition.section.case-statement.ts + + 2 + + name + meta.block.ts punctuation.definition.block.ts + + + end + \} + endCaptures + + 0 + + name + meta.block.ts punctuation.definition.block.ts + + + contentName + meta.block.ts + patterns + + + include + #statements + + + + + match + (:) + captures + + 0 + + name + case-clause.expr.ts punctuation.definition.section.case-statement.ts + + + + + include + #statements + + + + + + for-loop + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))for(?=((\s+|(\s*\/\*([^\*]|(\*[^\/]))*\*\/\s*))await)?\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)?(\()) + beginCaptures + + 0 + + name + keyword.control.loop.ts + + + end + (?<=\)) + patterns + + + include + #comment + + + name + keyword.control.loop.ts + match + await + + + begin + \( + beginCaptures + + 0 + + name + meta.brace.round.ts + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.ts + + + patterns + + + include + #var-expr + + + include + #expression + + + include + #punctuation-semicolon + + + + + + if-statement + + patterns + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bif\s*(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))\s*(?!\{)) + end + (?=;|$|\}) + patterns + + + include + #comment + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(if)\s*(\() + beginCaptures + + 1 + + name + keyword.control.conditional.ts + + 2 + + name + meta.brace.round.ts + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.ts + + + patterns + + + include + #expression + + + + + name + string.regexp.ts + begin + (?<=\))\s*\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/([dgimsuvy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$])) + beginCaptures + + 0 + + name + punctuation.definition.string.begin.ts + + + end + (/)([dgimsuvy]*) + endCaptures + + 1 + + name + punctuation.definition.string.end.ts + + 2 + + name + keyword.other.ts + + + patterns + + + include + #regexp + + + + + include + #statements + + + + + + decl-block + + name + meta.block.ts + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.ts + + + patterns + + + include + #statements + + + + after-operator-block-as-object-literal + + name + meta.objectliteral.ts + begin + (?<!\+\+|--)(?<=[:=(,\[?+!>]|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^yield|[^\._$[:alnum:]]yield|^throw|[^\._$[:alnum:]]throw|^in|[^\._$[:alnum:]]in|^of|[^\._$[:alnum:]]of|^typeof|[^\._$[:alnum:]]typeof|&&|\|\||\*)\s*(\{) + beginCaptures + + 1 + + name + punctuation.definition.block.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.ts + + + patterns + + + include + #object-member + + + + object-literal + + name + meta.objectliteral.ts + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.ts + + + patterns + + + include + #object-member + + + + object-member + + patterns + + + include + #comment + + + include + #object-literal-method-declaration + + + name + meta.object.member.ts meta.object-literal.key.ts + begin + (?=\[) + end + (?=:)|((?<=[\]])(?=\s*[\(\<])) + patterns + + + include + #comment + + + include + #array-literal + + + + + name + meta.object.member.ts meta.object-literal.key.ts + begin + (?=[\'\"\`]) + end + (?=:)|((?<=[\'\"\`])(?=((\s*[\(\<,}])|(\s+(as|satisifies)\s+)))) + patterns + + + include + #comment + + + include + #string + + + + + name + meta.object.member.ts meta.object-literal.key.ts + begin + (?x)(?=(\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))) + end + (?=:)|(?=\s*([\(\<,}])|(\s+as|satisifies\s+)) + patterns + + + include + #comment + + + include + #numeric-literal + + + + + name + meta.method.declaration.ts + begin + (?<=[\]\'\"\`])(?=\s*[\(\<]) + end + (?=\}|;|,)|(?<=\}) + patterns + + + include + #function-body + + + + + name + meta.object.member.ts + match + (?![_$[:alpha:]])([[:digit:]]+)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:) + captures + + 0 + + name + meta.object-literal.key.ts + + 1 + + name + constant.numeric.decimal.ts + + + + + name + meta.object.member.ts + match + (?x)(?:([_$[:alpha:]][_$[:alnum:]]*)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:(\s*\/\*([^\*]|(\*[^\/]))*\*\/)*\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | + +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +))) + captures + + 0 + + name + meta.object-literal.key.ts + + 1 + + name + entity.name.function.ts + + + + + name + meta.object.member.ts + match + (?:[_$[:alpha:]][_$[:alnum:]]*)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:) + captures + + 0 + + name + meta.object-literal.key.ts + + + + + name + meta.object.member.ts + begin + \.\.\. + beginCaptures + + 0 + + name + keyword.operator.spread.ts + + + end + (?=,|\}) + patterns + + + include + #expression + + + + + name + meta.object.member.ts + match + ([_$[:alpha:]][_$[:alnum:]]*)\s*(?=,|\}|$|\/\/|\/\*) + captures + + 1 + + name + variable.other.readwrite.ts + + + + + name + meta.object.member.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+(const)(?=\s*([,}]|$)) + captures + + 1 + + name + keyword.control.as.ts + + 2 + + name + storage.modifier.ts + + + + + name + meta.object.member.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(as)|(satisfies))\s+ + beginCaptures + + 1 + + name + keyword.control.as.ts + + 2 + + name + keyword.control.satisfies.ts + + + end + (?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|^|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as|satisifies)\s+)) + patterns + + + include + #type + + + + + name + meta.object.member.ts + begin + (?=[_$[:alpha:]][_$[:alnum:]]*\s*=) + end + (?=,|\}|$|\/\/|\/\*) + patterns + + + include + #expression + + + + + name + meta.object.member.ts + begin + : + beginCaptures + + 0 + + name + meta.object-literal.key.ts punctuation.separator.key-value.ts + + + end + (?=,|\}) + patterns + + + begin + (?<=:)\s*(async)?(?=\s*(<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))) + beginCaptures + + 1 + + name + storage.modifier.async.ts + + + end + (?<=\)) + patterns + + + include + #type-parameters + + + begin + \( + beginCaptures + + 0 + + name + meta.brace.round.ts + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.ts + + + patterns + + + include + #expression-inside-possibly-arrow-parens + + + + + + + begin + (?<=:)\s*(async)?\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))) + beginCaptures + + 1 + + name + storage.modifier.async.ts + + 2 + + name + meta.brace.round.ts + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.ts + + + patterns + + + include + #expression-inside-possibly-arrow-parens + + + + + begin + (?<=:)\s*(async)?\s*(?=\<\s*$) + beginCaptures + + 1 + + name + storage.modifier.async.ts + + + end + (?<=\>) + patterns + + + include + #type-parameters + + + + + begin + (?<=\>)\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))) + beginCaptures + + 1 + + name + meta.brace.round.ts + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.ts + + + patterns + + + include + #expression-inside-possibly-arrow-parens + + + + + include + #possibly-arrow-return-type + + + include + #expression + + + + + include + #punctuation-comma + + + include + #decl-block + + + + ternary-expression + + begin + (?!\?\.\s*[^[:digit:]])(\?)(?!\?) + beginCaptures + + 1 + + name + keyword.operator.ternary.ts + + + end + \s*(:) + endCaptures + + 1 + + name + keyword.operator.ternary.ts + + + patterns + + + include + #expression + + + + function-call + + patterns + + + begin + (?=(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\()) + end + (?<=\))(?!(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\()) + patterns + + + name + meta.function-call.ts + begin + (?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*)) + end + (?=\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\()) + patterns + + + include + #function-call-target + + + + + include + #comment + + + include + #function-call-optionals + + + include + #type-arguments + + + include + #paren-expression + + + + + begin + (?=(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))(<\s*[\{\[\(]\s*$)) + end + (?<=\>)(?!(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))(<\s*[\{\[\(]\s*$)) + patterns + + + name + meta.function-call.ts + begin + (?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*)) + end + (?=(<\s*[\{\[\(]\s*$)) + patterns + + + include + #function-call-target + + + + + include + #comment + + + include + #function-call-optionals + + + include + #type-arguments + + + + + + function-call-target + + patterns + + + include + #support-function-call-identifiers + + + name + entity.name.function.ts + match + (\#?[_$[:alpha:]][_$[:alnum:]]*) + + + + function-call-optionals + + patterns + + + name + meta.function-call.ts punctuation.accessor.optional.ts + match + \?\. + + + name + meta.function-call.ts keyword.operator.definiteassignment.ts + match + \! + + + + support-function-call-identifiers + + patterns + + + include + #literal + + + include + #support-objects + + + include + #object-identifiers + + + include + #punctuation-accessor + + + name + keyword.operator.expression.import.ts + match + (?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*[\(]\s*[\"\'\`])) + + + + new-expr + + name + new.expr.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + keyword.operator.new.ts + + + end + (?<=\))|(?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(])))) + patterns + + + include + #expression + + + + instanceof-expr + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(instanceof)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + keyword.operator.expression.instanceof.ts + + + end + (?<=\))|(?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|(===|!==|==|!=)|(([\&\~\^\|]\s*)?[_$[:alpha:]][_$[:alnum:]]*\s+instanceof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(])))) + patterns + + + include + #type + + + + paren-expression-possibly-arrow + + patterns + + + begin + (?<=[(=,])\s*(async)?(?=\s*((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))) + beginCaptures + + 1 + + name + storage.modifier.async.ts + + + end + (?<=\)) + patterns + + + include + #paren-expression-possibly-arrow-with-typeparameters + + + + + begin + (?<=[(=,]|=>|^return|[^\._$[:alnum:]]return)\s*(async)?(?=\s*((((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\()|(<)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)))\s*$) + beginCaptures + + 1 + + name + storage.modifier.async.ts + + + end + (?<=\)) + patterns + + + include + #paren-expression-possibly-arrow-with-typeparameters + + + + + include + #possibly-arrow-return-type + + + + paren-expression-possibly-arrow-with-typeparameters + + patterns + + + include + #type-parameters + + + begin + \( + beginCaptures + + 0 + + name + meta.brace.round.ts + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.ts + + + patterns + + + include + #expression-inside-possibly-arrow-parens + + + + + + expression-inside-possibly-arrow-parens + + patterns + + + include + #expressionWithoutIdentifiers + + + include + #comment + + + include + #string + + + include + #decorator + + + include + #destructuring-parameter + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|protected|private|readonly)\s+(?=(override|public|protected|private|readonly)\s+) + captures + + 1 + + name + storage.modifier.ts + + + + + match + (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s* +# function assignment | +(=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | + +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +)) | +# typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => +(:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) +)) | +(:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) | +(:\s*((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | +(:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | + +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +))) + captures + + 1 + + name + storage.modifier.ts + + 2 + + name + keyword.operator.rest.ts + + 3 + + name + entity.name.function.ts variable.language.this.ts + + 4 + + name + entity.name.function.ts + + 5 + + name + keyword.operator.optional.ts + + + + + match + (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s*[:,]|$) + captures + + 1 + + name + storage.modifier.ts + + 2 + + name + keyword.operator.rest.ts + + 3 + + name + variable.parameter.ts variable.language.this.ts + + 4 + + name + variable.parameter.ts + + 5 + + name + keyword.operator.optional.ts + + + + + include + #type-annotation + + + include + #variable-initializer + + + name + punctuation.separator.parameter.ts + match + , + + + include + #identifiers + + + include + #expressionPunctuations + + + + paren-expression + + begin + \( + beginCaptures + + 0 + + name + meta.brace.round.ts + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.ts + + + patterns + + + include + #expression + + + + cast + + patterns + + + name + cast.expr.ts + match + \s*(<)\s*(const)\s*(>) + captures + + 1 + + name + meta.brace.angle.ts + + 2 + + name + storage.modifier.ts + + 3 + + name + meta.brace.angle.ts + + + + + name + cast.expr.ts + begin + (?:(?<!\+\+|--)(?<=^return|[^\._$[:alnum:]]return|^throw|[^\._$[:alnum:]]throw|^yield|[^\._$[:alnum:]]yield|^await|[^\._$[:alnum:]]await|^default|[^\._$[:alnum:]]default|[=(,:>*?\&\|\^]|[^_$[:alnum:]](?:\+\+|\-\-)|[^\+]\+|[^\-]\-))\s*(<)(?!<?\=)(?!\s*$) + beginCaptures + + 1 + + name + meta.brace.angle.ts + + + end + (\>) + endCaptures + + 1 + + name + meta.brace.angle.ts + + + patterns + + + include + #type + + + + + name + cast.expr.ts + begin + (?:(?<=^))\s*(<)(?=[_$[:alpha:]][_$[:alnum:]]*\s*>) + beginCaptures + + 1 + + name + meta.brace.angle.ts + + + end + (\>) + endCaptures + + 1 + + name + meta.brace.angle.ts + + + patterns + + + include + #type + + + + + + expression-operators + + patterns + + + name + keyword.control.flow.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(await)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(yield)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?=\s*\/\*([^\*]|(\*[^\/]))*\*\/\s*\*) + beginCaptures + + 1 + + name + keyword.control.flow.ts + + + end + \* + endCaptures + + 0 + + name + keyword.generator.asterisk.ts + + + patterns + + + include + #comment + + + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(yield)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?:\s*(\*))? + captures + + 1 + + name + keyword.control.flow.ts + + 2 + + name + keyword.generator.asterisk.ts + + + + + name + keyword.operator.expression.delete.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))delete(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.operator.expression.in.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))in(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?!\() + + + name + keyword.operator.expression.of.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))of(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?!\() + + + name + keyword.operator.expression.instanceof.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))instanceof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.operator.new.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + include + #typeof-operator + + + name + keyword.operator.expression.void.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))void(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+(const)(?=\s*($|[;,:})\]])) + captures + + 1 + + name + keyword.control.as.ts + + 2 + + name + storage.modifier.ts + + + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(as)|(satisfies))\s+ + beginCaptures + + 1 + + name + keyword.control.as.ts + + 2 + + name + keyword.control.satisfies.ts + + + end + (?=^|[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as|satisfies)\s+)|(\s+\<)) + patterns + + + include + #type + + + + + name + keyword.operator.spread.ts + match + \.\.\. + + + name + keyword.operator.assignment.compound.ts + match + \*=|(?<!\()/=|%=|\+=|\-= + + + name + keyword.operator.assignment.compound.bitwise.ts + match + \&=|\^=|<<=|>>=|>>>=|\|= + + + name + keyword.operator.bitwise.shift.ts + match + <<|>>>|>> + + + name + keyword.operator.comparison.ts + match + ===|!==|==|!= + + + name + keyword.operator.relational.ts + match + <=|>=|<>|<|> + + + match + (?<=[_$[:alnum:]])(\!)\s*(?:(/=)|(?:(/)(?![/*]))) + captures + + 1 + + name + keyword.operator.logical.ts + + 2 + + name + keyword.operator.assignment.compound.ts + + 3 + + name + keyword.operator.arithmetic.ts + + + + + name + keyword.operator.logical.ts + match + \!|&&|\|\||\?\? + + + name + keyword.operator.bitwise.ts + match + \&|~|\^|\| + + + name + keyword.operator.assignment.ts + match + \= + + + name + keyword.operator.decrement.ts + match + -- + + + name + keyword.operator.increment.ts + match + \+\+ + + + name + keyword.operator.arithmetic.ts + match + %|\*|/|-|\+ + + + begin + (?<=[_$[:alnum:])\]])\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)+(?:(/=)|(?:(/)(?![/*])))) + end + (?:(/=)|(?:(/)(?!\*([^\*]|(\*[^\/]))*\*\/))) + endCaptures + + 1 + + name + keyword.operator.assignment.compound.ts + + 2 + + name + keyword.operator.arithmetic.ts + + + patterns + + + include + #comment + + + + + match + (?<=[_$[:alnum:])\]])\s*(?:(/=)|(?:(/)(?![/*]))) + captures + + 1 + + name + keyword.operator.assignment.compound.ts + + 2 + + name + keyword.operator.arithmetic.ts + + + + + + typeof-operator + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))typeof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 0 + + name + keyword.operator.expression.typeof.ts + + + end + (?=[,);}\]=>:&|{\?]|(extends\s+)|$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #type-arguments + + + include + #expression + + + + literal + + patterns + + + include + #numeric-literal + + + include + #boolean-literal + + + include + #null-literal + + + include + #undefined-literal + + + include + #numericConstant-literal + + + include + #array-literal + + + include + #this-literal + + + include + #super-literal + + + + array-literal + + name + meta.array.literal.ts + begin + \s*(\[) + beginCaptures + + 1 + + name + meta.brace.square.ts + + + end + \] + endCaptures + + 0 + + name + meta.brace.square.ts + + + patterns + + + include + #expression + + + include + #punctuation-comma + + + + numeric-literal + + patterns + + + name + constant.numeric.hex.ts + match + \b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$) + captures + + 1 + + name + storage.type.numeric.bigint.ts + + + + + name + constant.numeric.binary.ts + match + \b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$) + captures + + 1 + + name + storage.type.numeric.bigint.ts + + + + + name + constant.numeric.octal.ts + match + \b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$) + captures + + 1 + + name + storage.type.numeric.bigint.ts + + + + + match + (?x) +(?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$) + captures + + 0 + + name + constant.numeric.decimal.ts + + 1 + + name + meta.delimiter.decimal.period.ts + + 2 + + name + storage.type.numeric.bigint.ts + + 3 + + name + meta.delimiter.decimal.period.ts + + 4 + + name + storage.type.numeric.bigint.ts + + 5 + + name + meta.delimiter.decimal.period.ts + + 6 + + name + storage.type.numeric.bigint.ts + + 7 + + name + storage.type.numeric.bigint.ts + + 8 + + name + meta.delimiter.decimal.period.ts + + 9 + + name + storage.type.numeric.bigint.ts + + 10 + + name + meta.delimiter.decimal.period.ts + + 11 + + name + storage.type.numeric.bigint.ts + + 12 + + name + meta.delimiter.decimal.period.ts + + 13 + + name + storage.type.numeric.bigint.ts + + 14 + + name + storage.type.numeric.bigint.ts + + + + + + boolean-literal + + patterns + + + name + constant.language.boolean.true.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))true(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + constant.language.boolean.false.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))false(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + + null-literal + + name + constant.language.null.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))null(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + this-literal + + name + variable.language.this.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))this\b(?!\$) + + super-literal + + name + variable.language.super.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))super\b(?!\$) + + undefined-literal + + name + constant.language.undefined.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))undefined(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + numericConstant-literal + + patterns + + + name + constant.language.nan.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))NaN(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + constant.language.infinity.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Infinity(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + + support-objects + + patterns + + + name + variable.language.arguments.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(arguments)\b(?!\$) + + + name + support.class.builtin.ts + match + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Array|ArrayBuffer|Atomics|BigInt|BigInt64Array|BigUint64Array|Boolean|DataView|Date|Float32Array + |Float64Array|Function|Generator|GeneratorFunction|Int8Array|Int16Array|Int32Array|Intl|Map|Number|Object|Proxy + |Reflect|RegExp|Set|SharedArrayBuffer|SIMD|String|Symbol|TypedArray + |Uint8Array|Uint16Array|Uint32Array|Uint8ClampedArray|WeakMap|WeakSet)\b(?!\$) + + + name + support.class.error.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))((Eval|Internal|Range|Reference|Syntax|Type|URI)?Error)\b(?!\$) + + + name + support.class.promise.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Promise)\b(?!\$) + + + name + support.function.ts + match + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(clear(Interval|Timeout)|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval| + isFinite|isNaN|parseFloat|parseInt|require|set(Interval|Timeout)|super|unescape|uneval)(?=\s*\() + + + match + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Math)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(?: + (abs|acos|acosh|asin|asinh|atan|atan2|atanh|cbrt|ceil|clz32|cos|cosh|exp| + expm1|floor|fround|hypot|imul|log|log10|log1p|log2|max|min|pow|random| + round|sign|sin|sinh|sqrt|tan|tanh|trunc) + | + (E|LN10|LN2|LOG10E|LOG2E|PI|SQRT1_2|SQRT2)))?\b(?!\$) + captures + + 1 + + name + support.constant.math.ts + + 2 + + name + punctuation.accessor.ts + + 3 + + name + punctuation.accessor.optional.ts + + 4 + + name + support.function.math.ts + + 5 + + name + support.constant.property.math.ts + + + + + match + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(console)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*( + assert|clear|count|debug|dir|error|group|groupCollapsed|groupEnd|info|log + |profile|profileEnd|table|time|timeEnd|timeStamp|trace|warn))?\b(?!\$) + captures + + 1 + + name + support.class.console.ts + + 2 + + name + punctuation.accessor.ts + + 3 + + name + punctuation.accessor.optional.ts + + 4 + + name + support.function.console.ts + + + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(JSON)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(parse|stringify))?\b(?!\$) + captures + + 1 + + name + support.constant.json.ts + + 2 + + name + punctuation.accessor.ts + + 3 + + name + punctuation.accessor.optional.ts + + 4 + + name + support.function.json.ts + + + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(import)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(meta)\b(?!\$) + captures + + 1 + + name + keyword.control.import.ts + + 2 + + name + punctuation.accessor.ts + + 3 + + name + punctuation.accessor.optional.ts + + 4 + + name + support.variable.property.importmeta.ts + + + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(target)\b(?!\$) + captures + + 1 + + name + keyword.operator.new.ts + + 2 + + name + punctuation.accessor.ts + + 3 + + name + punctuation.accessor.optional.ts + + 4 + + name + support.variable.property.target.ts + + + + + match + (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?: + (?:(constructor|length|prototype|__proto__)\b(?!\$|\s*(<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\()) + | + (?:(EPSILON|MAX_SAFE_INTEGER|MAX_VALUE|MIN_SAFE_INTEGER|MIN_VALUE|NEGATIVE_INFINITY|POSITIVE_INFINITY)\b(?!\$))) + captures + + 1 + + name + punctuation.accessor.ts + + 2 + + name + punctuation.accessor.optional.ts + + 3 + + name + support.variable.property.ts + + 4 + + name + support.constant.ts + + + + + match + (?x) (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.)) \b (?: + (document|event|navigator|performance|screen|window) + | + (AnalyserNode|ArrayBufferView|Attr|AudioBuffer|AudioBufferSourceNode|AudioContext|AudioDestinationNode|AudioListener + |AudioNode|AudioParam|BatteryManager|BeforeUnloadEvent|BiquadFilterNode|Blob|BufferSource|ByteString|CSS|CSSConditionRule + |CSSCounterStyleRule|CSSGroupingRule|CSSMatrix|CSSMediaRule|CSSPageRule|CSSPrimitiveValue|CSSRule|CSSRuleList|CSSStyleDeclaration + |CSSStyleRule|CSSStyleSheet|CSSSupportsRule|CSSValue|CSSValueList|CanvasGradient|CanvasImageSource|CanvasPattern + |CanvasRenderingContext2D|ChannelMergerNode|ChannelSplitterNode|CharacterData|ChromeWorker|CloseEvent|Comment|CompositionEvent + |Console|ConvolverNode|Coordinates|Credential|CredentialsContainer|Crypto|CryptoKey|CustomEvent|DOMError|DOMException + |DOMHighResTimeStamp|DOMImplementation|DOMString|DOMStringList|DOMStringMap|DOMTimeStamp|DOMTokenList|DataTransfer + |DataTransferItem|DataTransferItemList|DedicatedWorkerGlobalScope|DelayNode|DeviceProximityEvent|DirectoryEntry + |DirectoryEntrySync|DirectoryReader|DirectoryReaderSync|Document|DocumentFragment|DocumentTouch|DocumentType|DragEvent + |DynamicsCompressorNode|Element|Entry|EntrySync|ErrorEvent|Event|EventListener|EventSource|EventTarget|FederatedCredential + |FetchEvent|File|FileEntry|FileEntrySync|FileException|FileList|FileReader|FileReaderSync|FileSystem|FileSystemSync + |FontFace|FormData|GainNode|Gamepad|GamepadButton|GamepadEvent|Geolocation|GlobalEventHandlers|HTMLAnchorElement + |HTMLAreaElement|HTMLAudioElement|HTMLBRElement|HTMLBaseElement|HTMLBodyElement|HTMLButtonElement|HTMLCanvasElement + |HTMLCollection|HTMLContentElement|HTMLDListElement|HTMLDataElement|HTMLDataListElement|HTMLDialogElement|HTMLDivElement + |HTMLDocument|HTMLElement|HTMLEmbedElement|HTMLFieldSetElement|HTMLFontElement|HTMLFormControlsCollection|HTMLFormElement + |HTMLHRElement|HTMLHeadElement|HTMLHeadingElement|HTMLHtmlElement|HTMLIFrameElement|HTMLImageElement|HTMLInputElement + |HTMLKeygenElement|HTMLLIElement|HTMLLabelElement|HTMLLegendElement|HTMLLinkElement|HTMLMapElement|HTMLMediaElement + |HTMLMetaElement|HTMLMeterElement|HTMLModElement|HTMLOListElement|HTMLObjectElement|HTMLOptGroupElement|HTMLOptionElement + |HTMLOptionsCollection|HTMLOutputElement|HTMLParagraphElement|HTMLParamElement|HTMLPreElement|HTMLProgressElement + |HTMLQuoteElement|HTMLScriptElement|HTMLSelectElement|HTMLShadowElement|HTMLSourceElement|HTMLSpanElement|HTMLStyleElement + |HTMLTableCaptionElement|HTMLTableCellElement|HTMLTableColElement|HTMLTableDataCellElement|HTMLTableElement|HTMLTableHeaderCellElement + |HTMLTableRowElement|HTMLTableSectionElement|HTMLTextAreaElement|HTMLTimeElement|HTMLTitleElement|HTMLTrackElement + |HTMLUListElement|HTMLUnknownElement|HTMLVideoElement|HashChangeEvent|History|IDBCursor|IDBCursorWithValue|IDBDatabase + |IDBEnvironment|IDBFactory|IDBIndex|IDBKeyRange|IDBMutableFile|IDBObjectStore|IDBOpenDBRequest|IDBRequest|IDBTransaction + |IDBVersionChangeEvent|IIRFilterNode|IdentityManager|ImageBitmap|ImageBitmapFactories|ImageData|Index|InputDeviceCapabilities + |InputEvent|InstallEvent|InstallTrigger|KeyboardEvent|LinkStyle|LocalFileSystem|LocalFileSystemSync|Location|MIDIAccess + |MIDIConnectionEvent|MIDIInput|MIDIInputMap|MIDIOutputMap|MediaElementAudioSourceNode|MediaError|MediaKeyMessageEvent + |MediaKeySession|MediaKeyStatusMap|MediaKeySystemAccess|MediaKeySystemConfiguration|MediaKeys|MediaRecorder|MediaStream + |MediaStreamAudioDestinationNode|MediaStreamAudioSourceNode|MessageChannel|MessageEvent|MessagePort|MouseEvent + |MutationObserver|MutationRecord|NamedNodeMap|Navigator|NavigatorConcurrentHardware|NavigatorGeolocation|NavigatorID + |NavigatorLanguage|NavigatorOnLine|Node|NodeFilter|NodeIterator|NodeList|NonDocumentTypeChildNode|Notification + |OfflineAudioCompletionEvent|OfflineAudioContext|OscillatorNode|PageTransitionEvent|PannerNode|ParentNode|PasswordCredential + |Path2D|PaymentAddress|PaymentRequest|PaymentResponse|Performance|PerformanceEntry|PerformanceFrameTiming|PerformanceMark + |PerformanceMeasure|PerformanceNavigation|PerformanceNavigationTiming|PerformanceObserver|PerformanceObserverEntryList + |PerformanceResourceTiming|PerformanceTiming|PeriodicSyncEvent|PeriodicWave|Plugin|Point|PointerEvent|PopStateEvent + |PortCollection|Position|PositionError|PositionOptions|PresentationConnectionClosedEvent|PresentationConnectionList + |PresentationReceiver|ProcessingInstruction|ProgressEvent|PromiseRejectionEvent|PushEvent|PushRegistrationManager + |RTCCertificate|RTCConfiguration|RTCPeerConnection|RTCSessionDescriptionCallback|RTCStatsReport|RadioNodeList|RandomSource + |Range|ReadableByteStream|RenderingContext|SVGAElement|SVGAngle|SVGAnimateColorElement|SVGAnimateElement|SVGAnimateMotionElement + |SVGAnimateTransformElement|SVGAnimatedAngle|SVGAnimatedBoolean|SVGAnimatedEnumeration|SVGAnimatedInteger|SVGAnimatedLength + |SVGAnimatedLengthList|SVGAnimatedNumber|SVGAnimatedNumberList|SVGAnimatedPoints|SVGAnimatedPreserveAspectRatio + |SVGAnimatedRect|SVGAnimatedString|SVGAnimatedTransformList|SVGAnimationElement|SVGCircleElement|SVGClipPathElement + |SVGCursorElement|SVGDefsElement|SVGDescElement|SVGElement|SVGEllipseElement|SVGEvent|SVGFilterElement|SVGFontElement + |SVGFontFaceElement|SVGFontFaceFormatElement|SVGFontFaceNameElement|SVGFontFaceSrcElement|SVGFontFaceUriElement + |SVGForeignObjectElement|SVGGElement|SVGGlyphElement|SVGGradientElement|SVGHKernElement|SVGImageElement|SVGLength + |SVGLengthList|SVGLineElement|SVGLinearGradientElement|SVGMPathElement|SVGMaskElement|SVGMatrix|SVGMissingGlyphElement + |SVGNumber|SVGNumberList|SVGPathElement|SVGPatternElement|SVGPoint|SVGPolygonElement|SVGPolylineElement|SVGPreserveAspectRatio + |SVGRadialGradientElement|SVGRect|SVGRectElement|SVGSVGElement|SVGScriptElement|SVGSetElement|SVGStopElement|SVGStringList + |SVGStylable|SVGStyleElement|SVGSwitchElement|SVGSymbolElement|SVGTRefElement|SVGTSpanElement|SVGTests|SVGTextElement + |SVGTextPositioningElement|SVGTitleElement|SVGTransform|SVGTransformList|SVGTransformable|SVGUseElement|SVGVKernElement + |SVGViewElement|ServiceWorker|ServiceWorkerContainer|ServiceWorkerGlobalScope|ServiceWorkerRegistration|ServiceWorkerState + |ShadowRoot|SharedWorker|SharedWorkerGlobalScope|SourceBufferList|StereoPannerNode|Storage|StorageEvent|StyleSheet + |StyleSheetList|SubtleCrypto|SyncEvent|Text|TextMetrics|TimeEvent|TimeRanges|Touch|TouchEvent|TouchList|Transferable + |TreeWalker|UIEvent|USVString|VRDisplayCapabilities|ValidityState|WaveShaperNode|WebGL|WebGLActiveInfo|WebGLBuffer + |WebGLContextEvent|WebGLFramebuffer|WebGLProgram|WebGLRenderbuffer|WebGLRenderingContext|WebGLShader|WebGLShaderPrecisionFormat + |WebGLTexture|WebGLTimerQueryEXT|WebGLTransformFeedback|WebGLUniformLocation|WebGLVertexArrayObject|WebGLVertexArrayObjectOES + |WebSocket|WebSockets|WebVTT|WheelEvent|Window|WindowBase64|WindowEventHandlers|WindowTimers|Worker|WorkerGlobalScope + |WorkerLocation|WorkerNavigator|XMLHttpRequest|XMLHttpRequestEventTarget|XMLSerializer|XPathExpression|XPathResult + |XSLTProcessor))\b(?!\$) + captures + + 1 + + name + support.variable.dom.ts + + 2 + + name + support.class.dom.ts + + + + + match + (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?: + (ATTRIBUTE_NODE|CDATA_SECTION_NODE|COMMENT_NODE|DOCUMENT_FRAGMENT_NODE|DOCUMENT_NODE|DOCUMENT_TYPE_NODE + |DOMSTRING_SIZE_ERR|ELEMENT_NODE|ENTITY_NODE|ENTITY_REFERENCE_NODE|HIERARCHY_REQUEST_ERR|INDEX_SIZE_ERR + |INUSE_ATTRIBUTE_ERR|INVALID_CHARACTER_ERR|NO_DATA_ALLOWED_ERR|NO_MODIFICATION_ALLOWED_ERR|NOT_FOUND_ERR + |NOT_SUPPORTED_ERR|NOTATION_NODE|PROCESSING_INSTRUCTION_NODE|TEXT_NODE|WRONG_DOCUMENT_ERR) + | + (_content|[xyz]|abbr|above|accept|acceptCharset|accessKey|action|align|[av]Link(?:color)?|all|alt|anchors|appCodeName + |appCore|applets|appMinorVersion|appName|appVersion|archive|areas|arguments|attributes|availHeight|availLeft|availTop + |availWidth|axis|background|backgroundColor|backgroundImage|below|bgColor|body|border|borderBottomWidth|borderColor + |borderLeftWidth|borderRightWidth|borderStyle|borderTopWidth|borderWidth|bottom|bufferDepth|callee|caller|caption + |cellPadding|cells|cellSpacing|ch|characterSet|charset|checked|childNodes|chOff|cite|classes|className|clear + |clientInformation|clip|clipBoardData|closed|code|codeBase|codeType|color|colorDepth|cols|colSpan|compact|complete + |components|content|controllers|cookie|cookieEnabled|cords|cpuClass|crypto|current|data|dateTime|declare|defaultCharset + |defaultChecked|defaultSelected|defaultStatus|defaultValue|defaultView|defer|description|dialogArguments|dialogHeight + |dialogLeft|dialogTop|dialogWidth|dir|directories|disabled|display|docmain|doctype|documentElement|elements|embeds + |enabledPlugin|encoding|enctype|entities|event|expando|external|face|fgColor|filename|firstChild|fontFamily|fontSize + |fontWeight|form|formName|forms|frame|frameBorder|frameElement|frames|hasFocus|hash|headers|height|history|host + |hostname|href|hreflang|hspace|htmlFor|httpEquiv|id|ids|ignoreCase|images|implementation|index|innerHeight|innerWidth + |input|isMap|label|lang|language|lastChild|lastIndex|lastMatch|lastModified|lastParen|layer[sXY]|left|leftContext + |lineHeight|link|linkColor|links|listStyleType|localName|location|locationbar|longDesc|lowsrc|lowSrc|marginBottom + |marginHeight|marginLeft|marginRight|marginTop|marginWidth|maxLength|media|menubar|method|mimeTypes|multiline|multiple + |name|nameProp|namespaces|namespaceURI|next|nextSibling|nodeName|nodeType|nodeValue|noHref|noResize|noShade|notationName + |notations|noWrap|object|offscreenBuffering|onLine|onreadystatechange|opener|opsProfile|options|oscpu|outerHeight + |outerWidth|ownerDocument|paddingBottom|paddingLeft|paddingRight|paddingTop|page[XY]|page[XY]Offset|parent|parentLayer + |parentNode|parentWindow|pathname|personalbar|pixelDepth|pkcs11|platform|plugins|port|prefix|previous|previousDibling + |product|productSub|profile|profileend|prompt|prompter|protocol|publicId|readOnly|readyState|referrer|rel|responseText + |responseXML|rev|right|rightContext|rowIndex|rows|rowSpan|rules|scheme|scope|screen[XY]|screenLeft|screenTop|scripts + |scrollbars|scrolling|sectionRowIndex|security|securityPolicy|selected|selectedIndex|selection|self|shape|siblingAbove + |siblingBelow|size|source|specified|standby|start|status|statusbar|statusText|style|styleSheets|suffixes|summary + |systemId|systemLanguage|tagName|tags|target|tBodies|text|textAlign|textDecoration|textIndent|textTransform|tFoot|tHead + |title|toolbar|top|type|undefined|uniqueID|updateInterval|URL|URLUnencoded|useMap|userAgent|userLanguage|userProfile + |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\() + captures + + 1 + + name + punctuation.accessor.ts + + 2 + + name + punctuation.accessor.optional.ts + + 3 + + name + support.constant.dom.ts + + 4 + + name + support.variable.property.dom.ts + + + + + name + support.class.node.ts + match + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Buffer|EventEmitter|Server|Pipe|Socket|REPLServer|ReadStream|WriteStream|Stream + |Inflate|Deflate|InflateRaw|DeflateRaw|GZip|GUnzip|Unzip|Zip)\b(?!\$) + + + match + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(process)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))(?: + (arch|argv|config|connected|env|execArgv|execPath|exitCode|mainModule|pid|platform|release|stderr|stdin|stdout|title|version|versions) + | + (abort|chdir|cwd|disconnect|exit|[sg]ete?[gu]id|send|[sg]etgroups|initgroups|kill|memoryUsage|nextTick|umask|uptime|hrtime) +))?\b(?!\$) + captures + + 1 + + name + support.variable.object.process.ts + + 2 + + name + punctuation.accessor.ts + + 3 + + name + punctuation.accessor.optional.ts + + 4 + + name + support.variable.property.process.ts + + 5 + + name + support.function.process.ts + + + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(exports)|(module)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))(exports|id|filename|loaded|parent|children))?)\b(?!\$) + captures + + 1 + + name + support.type.object.module.ts + + 2 + + name + support.type.object.module.ts + + 3 + + name + punctuation.accessor.ts + + 4 + + name + punctuation.accessor.optional.ts + + 5 + + name + support.type.object.module.ts + + + + + name + support.variable.object.node.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(global|GLOBAL|root|__dirname|__filename)\b(?!\$) + + + match + (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* +(?: + (on(?:Rowsinserted|Rowsdelete|Rowenter|Rowexit|Resize|Resizestart|Resizeend|Reset| + Readystatechange|Mouseout|Mouseover|Mousedown|Mouseup|Mousemove| + Before(?:cut|deactivate|unload|update|paste|print|editfocus|activate)| + Blur|Scrolltop|Submit|Select|Selectstart|Selectionchange|Hover|Help| + Change|Contextmenu|Controlselect|Cut|Cellchange|Clock|Close|Deactivate| + Datasetchanged|Datasetcomplete|Dataavailable|Drop|Drag|Dragstart|Dragover| + Dragdrop|Dragenter|Dragend|Dragleave|Dblclick|Unload|Paste|Propertychange|Error| + Errorupdate|Keydown|Keyup|Keypress|Focus|Load|Activate|Afterupdate|Afterprint|Abort) + ) | + (shift|showModelessDialog|showModalDialog|showHelp|scroll|scrollX|scrollByPages| + scrollByLines|scrollY|scrollTo|stop|strike|sizeToContent|sidebar|signText|sort| + sup|sub|substr|substring|splice|split|send|set(?:Milliseconds|Seconds|Minutes|Hours| + Month|Year|FullYear|Date|UTC(?:Milliseconds|Seconds|Minutes|Hours|Month|FullYear|Date)| + Time|Hotkeys|Cursor|ZOptions|Active|Resizable|RequestHeader)|search|slice| + savePreferences|small|home|handleEvent|navigate|char|charCodeAt|charAt|concat| + contextual|confirm|compile|clear|captureEvents|call|createStyleSheet|createPopup| + createEventObject|to(?:GMTString|UTCString|String|Source|UpperCase|LowerCase|LocaleString)| + test|taint|taintEnabled|indexOf|italics|disableExternalCapture|dump|detachEvent|unshift| + untaint|unwatch|updateCommands|join|javaEnabled|pop|push|plugins.refresh|paddings|parse| + print|prompt|preference|enableExternalCapture|exec|execScript|valueOf|UTC|find|file| + fileModifiedDate|fileSize|fileCreatedDate|fileUpdatedDate|fixed|fontsize|fontcolor| + forward|fromCharCode|watch|link|load|lastIndexOf|anchor|attachEvent|atob|apply|alert| + abort|routeEvents|resize|resizeBy|resizeTo|recalc|returnValue|replace|reverse|reload| + releaseCapture|releaseEvents|go|get(?:Milliseconds|Seconds|Minutes|Hours|Month|Day|Year|FullYear| + Time|Date|TimezoneOffset|UTC(?:Milliseconds|Seconds|Minutes|Hours|Day|Month|FullYear|Date)| + Attention|Selection|ResponseHeader|AllResponseHeaders)|moveBy|moveBelow|moveTo| + moveToAbsolute|moveAbove|mergeAttributes|match|margins|btoa|big|bold|borderWidths|blink|back + ) | + (acceptNode|add|addEventListener|addTextTrack|adoptNode|after|animate|append| + appendChild|appendData|before|blur|canPlayType|captureStream| + caretPositionFromPoint|caretRangeFromPoint|checkValidity|clear|click| + cloneContents|cloneNode|cloneRange|close|closest|collapse| + compareBoundaryPoints|compareDocumentPosition|comparePoint|contains| + convertPointFromNode|convertQuadFromNode|convertRectFromNode|createAttribute| + createAttributeNS|createCaption|createCDATASection|createComment| + createContextualFragment|createDocument|createDocumentFragment| + createDocumentType|createElement|createElementNS|createEntityReference| + createEvent|createExpression|createHTMLDocument|createNodeIterator| + createNSResolver|createProcessingInstruction|createRange|createShadowRoot| + createTBody|createTextNode|createTFoot|createTHead|createTreeWalker|delete| + deleteCaption|deleteCell|deleteContents|deleteData|deleteRow|deleteTFoot| + deleteTHead|detach|disconnect|dispatchEvent|elementFromPoint|elementsFromPoint| + enableStyleSheetsForSet|entries|evaluate|execCommand|exitFullscreen| + exitPointerLock|expand|extractContents|fastSeek|firstChild|focus|forEach|get| + getAll|getAnimations|getAttribute|getAttributeNames|getAttributeNode| + getAttributeNodeNS|getAttributeNS|getBoundingClientRect|getBoxQuads| + getClientRects|getContext|getDestinationInsertionPoints|getElementById| + getElementsByClassName|getElementsByName|getElementsByTagName| + getElementsByTagNameNS|getItem|getNamedItem|getSelection|getStartDate| + getVideoPlaybackQuality|has|hasAttribute|hasAttributeNS|hasAttributes| + hasChildNodes|hasFeature|hasFocus|importNode|initEvent|insertAdjacentElement| + insertAdjacentHTML|insertAdjacentText|insertBefore|insertCell|insertData| + insertNode|insertRow|intersectsNode|isDefaultNamespace|isEqualNode| + isPointInRange|isSameNode|item|key|keys|lastChild|load|lookupNamespaceURI| + lookupPrefix|matches|move|moveAttribute|moveAttributeNode|moveChild| + moveNamedItem|namedItem|nextNode|nextSibling|normalize|observe|open| + parentNode|pause|play|postMessage|prepend|preventDefault|previousNode| + previousSibling|probablySupportsContext|queryCommandEnabled| + queryCommandIndeterm|queryCommandState|queryCommandSupported|queryCommandValue| + querySelector|querySelectorAll|registerContentHandler|registerElement| + registerProtocolHandler|releaseCapture|releaseEvents|remove|removeAttribute| + removeAttributeNode|removeAttributeNS|removeChild|removeEventListener| + removeItem|replace|replaceChild|replaceData|replaceWith|reportValidity| + requestFullscreen|requestPointerLock|reset|scroll|scrollBy|scrollIntoView| + scrollTo|seekToNextFrame|select|selectNode|selectNodeContents|set|setAttribute| + setAttributeNode|setAttributeNodeNS|setAttributeNS|setCapture| + setCustomValidity|setEnd|setEndAfter|setEndBefore|setItem|setNamedItem| + setRangeText|setSelectionRange|setSinkId|setStart|setStartAfter|setStartBefore| + slice|splitText|stepDown|stepUp|stopImmediatePropagation|stopPropagation| + submit|substringData|supports|surroundContents|takeRecords|terminate|toBlob| + toDataURL|toggle|toString|values|write|writeln + ) | + (all|catch|finally|race|reject|resolve|then + ) +)(?=\s*\() + captures + + 1 + + name + punctuation.accessor.ts + + 2 + + name + punctuation.accessor.optional.ts + + 3 + + name + support.function.event-handler.ts + + 4 + + name + support.function.ts + + 5 + + name + support.function.dom.ts + + 6 + + name + support.function.promise.ts + + + + + + identifiers + + patterns + + + include + #object-identifiers + + + match + (?x)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*)?([_$[:alpha:]][_$[:alnum:]]*)(?=\s*=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | + +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +)) + captures + + 1 + + name + punctuation.accessor.ts + + 2 + + name + punctuation.accessor.optional.ts + + 3 + + name + entity.name.function.ts + + + + + match + (?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(\#?[[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]]) + captures + + 1 + + name + punctuation.accessor.ts + + 2 + + name + punctuation.accessor.optional.ts + + 3 + + name + variable.other.constant.property.ts + + + + + match + (?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(\#?[_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + punctuation.accessor.ts + + 2 + + name + punctuation.accessor.optional.ts + + 3 + + name + variable.other.property.ts + + + + + name + variable.other.constant.ts + match + ([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]]) + + + name + variable.other.readwrite.ts + match + [_$[:alpha:]][_$[:alnum:]]* + + + + object-identifiers + + patterns + + + name + support.class.ts + match + ([_$[:alpha:]][_$[:alnum:]]*)(?=\s*\??\.\s*prototype\b(?!\$)) + + + match + (?x)(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(?: + (\#?[[:upper:]][_$[:digit:][:upper:]]*) | + (\#?[_$[:alpha:]][_$[:alnum:]]*) +)(?=\s*\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + punctuation.accessor.ts + + 2 + + name + punctuation.accessor.optional.ts + + 3 + + name + variable.other.constant.object.property.ts + + 4 + + name + variable.other.object.property.ts + + + + + match + (?x)(?: + ([[:upper:]][_$[:digit:][:upper:]]*) | + ([_$[:alpha:]][_$[:alnum:]]*) +)(?=\s*\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + variable.other.constant.object.ts + + 2 + + name + variable.other.object.ts + + + + + + type-annotation + + patterns + + + name + meta.type.annotation.ts + begin + (:)(?=\s*\S) + beginCaptures + + 1 + + name + keyword.operator.type.annotation.ts + + + end + (?<![:|&])(?!\s*[|&]\s+)((?=^|[,);\}\]]|//)|(?==[^>])|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{))) + patterns + + + include + #type + + + + + name + meta.type.annotation.ts + begin + (:) + beginCaptures + + 1 + + name + keyword.operator.type.annotation.ts + + + end + (?<![:|&])((?=[,);\}\]]|\/\/)|(?==[^>])|(?=^\s*$)|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{))) + patterns + + + include + #type + + + + + + parameter-type-annotation + + patterns + + + name + meta.type.annotation.ts + begin + (:) + beginCaptures + + 1 + + name + keyword.operator.type.annotation.ts + + + end + (?=[,)])|(?==[^>]) + patterns + + + include + #type + + + + + + return-type + + patterns + + + name + meta.return.type.ts + begin + (?<=\))\s*(:)(?=\s*\S) + beginCaptures + + 1 + + name + keyword.operator.type.annotation.ts + + + end + (?<![:|&])(?=$|^|[{};,]|//) + patterns + + + include + #return-type-core + + + + + name + meta.return.type.ts + begin + (?<=\))\s*(:) + beginCaptures + + 1 + + name + keyword.operator.type.annotation.ts + + + end + (?<![:|&])((?=[{};,]|//|^\s*$)|((?<=\S)(?=\s*$))) + patterns + + + include + #return-type-core + + + + + + return-type-core + + patterns + + + include + #comment + + + begin + (?<=[:|&])(?=\s*\{) + end + (?<=\}) + patterns + + + include + #type-object + + + + + include + #type-predicate-operator + + + include + #type + + + + arrow-return-type + + name + meta.return.type.arrow.ts + begin + (?<=\))\s*(:) + beginCaptures + + 1 + + name + keyword.operator.type.annotation.ts + + + end + (?==>|\{|(^\s*(export|function|class|interface|let|var|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|const|import|enum|namespace|module|type|abstract|declare)\s+)) + patterns + + + include + #arrow-return-type-body + + + + possibly-arrow-return-type + + begin + (?<=\)|^)\s*(:)(?=\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*=>) + beginCaptures + + 1 + + name + meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts + + + end + (?==>|\{|(^\s*(export|function|class|interface|let|var|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|const|import|enum|namespace|module|type|abstract|declare)\s+)) + contentName + meta.arrow.ts meta.return.type.arrow.ts + patterns + + + include + #arrow-return-type-body + + + + arrow-return-type-body + + patterns + + + begin + (?<=[:])(?=\s*\{) + end + (?<=\}) + patterns + + + include + #type-object + + + + + include + #type-predicate-operator + + + include + #type + + + + type-parameters + + name + meta.type.parameters.ts + begin + (<) + beginCaptures + + 1 + + name + punctuation.definition.typeparameters.begin.ts + + + end + (>) + endCaptures + + 1 + + name + punctuation.definition.typeparameters.end.ts + + + patterns + + + include + #comment + + + name + storage.modifier.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(extends|in|out|const)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + include + #type + + + include + #punctuation-comma + + + name + keyword.operator.assignment.ts + match + (=)(?!>) + + + + type-arguments + + name + meta.type.parameters.ts + begin + \< + beginCaptures + + 0 + + name + punctuation.definition.typeparameters.begin.ts + + + end + \> + endCaptures + + 0 + + name + punctuation.definition.typeparameters.end.ts + + + patterns + + + include + #type-arguments-body + + + + type-arguments-body + + patterns + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(_)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + captures + + 0 + + name + keyword.operator.type.ts + + + + + include + #type + + + include + #punctuation-comma + + + + type + + patterns + + + include + #comment + + + include + #type-string + + + include + #numeric-literal + + + include + #type-primitive + + + include + #type-builtin-literals + + + include + #type-parameters + + + include + #type-tuple + + + include + #type-object + + + include + #type-operators + + + include + #type-conditional + + + include + #type-fn-type-parameters + + + include + #type-paren-or-function-parameters + + + include + #type-function-return-type + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s* + captures + + 1 + + name + storage.modifier.ts + + + + + include + #type-name + + + + type-primitive + + name + support.type.primitive.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(string|number|bigint|boolean|symbol|any|void|never|unknown)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + type-builtin-literals + + name + support.type.builtin.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(this|true|false|undefined|null|object)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + type-tuple + + name + meta.type.tuple.ts + begin + \[ + beginCaptures + + 0 + + name + meta.brace.square.ts + + + end + \] + endCaptures + + 0 + + name + meta.brace.square.ts + + + patterns + + + name + keyword.operator.rest.ts + match + \.\.\. + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))([_$[:alpha:]][_$[:alnum:]]*)\s*(\?)?\s*(:) + captures + + 1 + + name + entity.name.label.ts + + 2 + + name + keyword.operator.optional.ts + + 3 + + name + punctuation.separator.label.ts + + + + + include + #type + + + include + #punctuation-comma + + + + type-object + + name + meta.object.type.ts + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.ts + + + patterns + + + include + #comment + + + include + #method-declaration + + + include + #indexer-declaration + + + include + #indexer-mapped-type-declaration + + + include + #field-declaration + + + include + #type-annotation + + + begin + \.\.\. + beginCaptures + + 0 + + name + keyword.operator.spread.ts + + + end + (?=\}|;|,|$)|(?<=\}) + patterns + + + include + #type + + + + + include + #punctuation-comma + + + include + #punctuation-semicolon + + + include + #type + + + + type-conditional + + patterns + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(extends)\s+ + beginCaptures + + 1 + + name + storage.modifier.ts + + + end + (?<=:) + patterns + + + begin + \? + beginCaptures + + 0 + + name + keyword.operator.ternary.ts + + + end + : + endCaptures + + 0 + + name + keyword.operator.ternary.ts + + + patterns + + + include + #type + + + + + include + #type + + + + + + type-paren-or-function-parameters + + name + meta.type.paren.cover.ts + begin + \( + beginCaptures + + 0 + + name + meta.brace.round.ts + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.ts + + + patterns + + + match + (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))\s*(\??)(?=\s*(:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) +)) | +(:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) | +(:\s*((<\s*$)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))))) + captures + + 1 + + name + storage.modifier.ts + + 2 + + name + keyword.operator.rest.ts + + 3 + + name + entity.name.function.ts variable.language.this.ts + + 4 + + name + entity.name.function.ts + + 5 + + name + keyword.operator.optional.ts + + + + + match + (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))\s*(\??)(?=:) + captures + + 1 + + name + storage.modifier.ts + + 2 + + name + keyword.operator.rest.ts + + 3 + + name + variable.parameter.ts variable.language.this.ts + + 4 + + name + variable.parameter.ts + + 5 + + name + keyword.operator.optional.ts + + + + + include + #type-annotation + + + name + punctuation.separator.parameter.ts + match + , + + + include + #type + + + + type-fn-type-parameters + + patterns + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(new)\b(?=\s*\<) + beginCaptures + + 1 + + name + meta.type.constructor.ts storage.modifier.ts + + 2 + + name + meta.type.constructor.ts keyword.control.new.ts + + + end + (?<=>) + patterns + + + include + #comment + + + include + #type-parameters + + + + + name + meta.type.constructor.ts + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(new)\b\s*(?=\() + beginCaptures + + 1 + + name + storage.modifier.ts + + 2 + + name + keyword.control.new.ts + + + end + (?<=\)) + patterns + + + include + #function-parameters + + + + + name + meta.type.function.ts + begin + (?x)( + (?= + [(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + ) + ) +) + end + (?<=\)) + patterns + + + include + #function-parameters + + + + + + type-function-return-type + + patterns + + + name + meta.type.function.return.ts + begin + (=>)(?=\s*\S) + beginCaptures + + 1 + + name + storage.type.function.arrow.ts + + + end + (?<!=>)(?<![|&])(?=[,\]\)\{\}=;>:\?]|//|$) + patterns + + + include + #type-function-return-type-core + + + + + name + meta.type.function.return.ts + begin + => + beginCaptures + + 0 + + name + storage.type.function.arrow.ts + + + end + (?<!=>)(?<![|&])((?=[,\]\)\{\}=;:\?>]|//|^\s*$)|((?<=\S)(?=\s*$))) + patterns + + + include + #type-function-return-type-core + + + + + + type-function-return-type-core + + patterns + + + include + #comment + + + begin + (?<==>)(?=\s*\{) + end + (?<=\}) + patterns + + + include + #type-object + + + + + include + #type-predicate-operator + + + include + #type + + + + type-operators + + patterns + + + include + #typeof-operator + + + include + #type-infer + + + begin + ([&|])(?=\s*\{) + beginCaptures + + 0 + + name + keyword.operator.type.ts + + + end + (?<=\}) + patterns + + + include + #type-object + + + + + begin + [&|] + beginCaptures + + 0 + + name + keyword.operator.type.ts + + + end + (?=\S) + + + name + keyword.operator.expression.keyof.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))keyof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.operator.ternary.ts + match + (\?|\:) + + + name + keyword.operator.expression.import.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*\() + + + + type-infer + + patterns + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(infer)\s+([_$[:alpha:]][_$[:alnum:]]*)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?:\s+(extends)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))? + name + meta.type.infer.ts + captures + + 1 + + name + keyword.operator.expression.infer.ts + + 2 + + name + entity.name.type.ts + + 3 + + name + keyword.operator.expression.extends.ts + + + + + + type-predicate-operator + + patterns + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(asserts)\s+)?(?!asserts)(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))\s(is)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + captures + + 1 + + name + keyword.operator.type.asserts.ts + + 2 + + name + variable.parameter.ts variable.language.this.ts + + 3 + + name + variable.parameter.ts + + 4 + + name + keyword.operator.expression.is.ts + + + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(asserts)\s+(?!is)(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + captures + + 1 + + name + keyword.operator.type.asserts.ts + + 2 + + name + variable.parameter.ts variable.language.this.ts + + 3 + + name + variable.parameter.ts + + + + + name + keyword.operator.type.asserts.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))asserts(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.operator.expression.is.ts + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))is(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + + type-name + + patterns + + + begin + ([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(<) + captures + + 1 + + name + entity.name.type.module.ts + + 2 + + name + punctuation.accessor.ts + + 3 + + name + punctuation.accessor.optional.ts + + 4 + + name + meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + + + end + (>) + endCaptures + + 1 + + name + meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + + + contentName + meta.type.parameters.ts + patterns + + + include + #type-arguments-body + + + + + begin + ([_$[:alpha:]][_$[:alnum:]]*)\s*(<) + beginCaptures + + 1 + + name + entity.name.type.ts + + 2 + + name + meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + + + end + (>) + endCaptures + + 1 + + name + meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + + + contentName + meta.type.parameters.ts + patterns + + + include + #type-arguments-body + + + + + match + ([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]]))) + captures + + 1 + + name + entity.name.type.module.ts + + 2 + + name + punctuation.accessor.ts + + 3 + + name + punctuation.accessor.optional.ts + + + + + name + entity.name.type.ts + match + [_$[:alpha:]][_$[:alnum:]]* + + + + punctuation-comma + + name + punctuation.separator.comma.ts + match + , + + punctuation-semicolon + + name + punctuation.terminator.statement.ts + match + ; + + punctuation-accessor + + match + (?:(\.)|(\?\.(?!\s*[[:digit:]]))) + captures + + 1 + + name + punctuation.accessor.ts + + 2 + + name + punctuation.accessor.optional.ts + + + + string + + patterns + + + include + #qstring-single + + + include + #qstring-double + + + include + #template + + + + qstring-double + + name + string.quoted.double.ts + begin + " + beginCaptures + + 0 + + name + punctuation.definition.string.begin.ts + + + end + (")|((?:[^\\\n])$) + endCaptures + + 1 + + name + punctuation.definition.string.end.ts + + 2 + + name + invalid.illegal.newline.ts + + + patterns + + + include + #string-character-escape + + + + qstring-single + + name + string.quoted.single.ts + begin + ' + beginCaptures + + 0 + + name + punctuation.definition.string.begin.ts + + + end + (\')|((?:[^\\\n])$) + endCaptures + + 1 + + name + punctuation.definition.string.end.ts + + 2 + + name + invalid.illegal.newline.ts + + + patterns + + + include + #string-character-escape + + + + string-character-escape + + name + constant.character.escape.ts + match + \\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\{[0-9A-Fa-f]+\}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$) + + template + + patterns + + + include + #template-call + + + contentName + string.template.ts + begin + ([_$[:alpha:]][_$[:alnum:]]*)?(`) + beginCaptures + + 1 + + name + entity.name.function.tagged-template.ts + + 2 + + name + string.template.ts punctuation.definition.string.template.begin.ts + + + end + ` + endCaptures + + 0 + + name + string.template.ts punctuation.definition.string.template.end.ts + + + patterns + + + include + #template-substitution-element + + + include + #string-character-escape + + + + + + template-call + + patterns + + + begin + (?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?`) + end + (?=`) + patterns + + + begin + (?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)) + end + (?=(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?`) + patterns + + + include + #support-function-call-identifiers + + + name + entity.name.function.tagged-template.ts + match + ([_$[:alpha:]][_$[:alnum:]]*) + + + + + include + #type-arguments + + + + + begin + ([_$[:alpha:]][_$[:alnum:]]*)?\s*(?=(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)`) + beginCaptures + + 1 + + name + entity.name.function.tagged-template.ts + + + end + (?=`) + patterns + + + include + #type-arguments + + + + + + template-substitution-element + + name + meta.template.expression.ts + begin + \$\{ + beginCaptures + + 0 + + name + punctuation.definition.template-expression.begin.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.template-expression.end.ts + + + patterns + + + include + #expression + + + contentName + meta.embedded.line.ts + + type-string + + patterns + + + include + #qstring-single + + + include + #qstring-double + + + include + #template-type + + + + template-type + + patterns + + + include + #template-call + + + contentName + string.template.ts + begin + ([_$[:alpha:]][_$[:alnum:]]*)?(`) + beginCaptures + + 1 + + name + entity.name.function.tagged-template.ts + + 2 + + name + string.template.ts punctuation.definition.string.template.begin.ts + + + end + ` + endCaptures + + 0 + + name + string.template.ts punctuation.definition.string.template.end.ts + + + patterns + + + include + #template-type-substitution-element + + + include + #string-character-escape + + + + + + template-type-substitution-element + + name + meta.template.expression.ts + begin + \$\{ + beginCaptures + + 0 + + name + punctuation.definition.template-expression.begin.ts + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.template-expression.end.ts + + + patterns + + + include + #type + + + contentName + meta.embedded.line.ts + + regex + + patterns + + + name + string.regexp.ts + begin + (?<!\+\+|--|})(?<=[=(:,\[?+!]|^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[\()]|\\.|\[([^\]\\]|\\.)+\]|\(([^\)\\]|\\.)+\))+\/([dgimsuvy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$])) + beginCaptures + + 1 + + name + punctuation.definition.string.begin.ts + + + end + (/)([dgimsuvy]*) + endCaptures + + 1 + + name + punctuation.definition.string.end.ts + + 2 + + name + keyword.other.ts + + + patterns + + + include + #regexp + + + + + name + string.regexp.ts + begin + ((?<![_$[:alnum:])\]]|\+\+|--|}|\*\/)|((?<=^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case))\s*)\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/([dgimsuvy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$])) + beginCaptures + + 0 + + name + punctuation.definition.string.begin.ts + + + end + (/)([dgimsuvy]*) + endCaptures + + 1 + + name + punctuation.definition.string.end.ts + + 2 + + name + keyword.other.ts + + + patterns + + + include + #regexp + + + + + + regexp + + patterns + + + name + keyword.control.anchor.regexp + match + \\[bB]|\^|\$ + + + match + \\[1-9]\d*|\\k<([a-zA-Z_$][\w$]*)> + captures + + 0 + + name + keyword.other.back-reference.regexp + + 1 + + name + variable.other.regexp + + + + + name + keyword.operator.quantifier.regexp + match + [?+*]|\{(\d+,\d+|\d+,|,\d+|\d+)\}\?? + + + name + keyword.operator.or.regexp + match + \| + + + name + meta.group.assertion.regexp + begin + (\()((\?=)|(\?!)|(\?<=)|(\?<!)) + beginCaptures + + 1 + + name + punctuation.definition.group.regexp + + 2 + + name + punctuation.definition.group.assertion.regexp + + 3 + + name + meta.assertion.look-ahead.regexp + + 4 + + name + meta.assertion.negative-look-ahead.regexp + + 5 + + name + meta.assertion.look-behind.regexp + + 6 + + name + meta.assertion.negative-look-behind.regexp + + + end + (\)) + endCaptures + + 1 + + name + punctuation.definition.group.regexp + + + patterns + + + include + #regexp + + + + + name + meta.group.regexp + begin + \((?:(\?:)|(?:\?<([a-zA-Z_$][\w$]*)>))? + beginCaptures + + 0 + + name + punctuation.definition.group.regexp + + 1 + + name + punctuation.definition.group.no-capture.regexp + + 2 + + name + variable.other.regexp + + + end + \) + endCaptures + + 0 + + name + punctuation.definition.group.regexp + + + patterns + + + include + #regexp + + + + + name + constant.other.character-class.set.regexp + begin + (\[)(\^)? + beginCaptures + + 1 + + name + punctuation.definition.character-class.regexp + + 2 + + name + keyword.operator.negation.regexp + + + end + (\]) + endCaptures + + 1 + + name + punctuation.definition.character-class.regexp + + + patterns + + + name + constant.other.character-class.range.regexp + match + (?:.|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.))\-(?:[^\]\\]|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.)) + captures + + 1 + + name + constant.character.numeric.regexp + + 2 + + name + constant.character.control.regexp + + 3 + + name + constant.character.escape.backslash.regexp + + 4 + + name + constant.character.numeric.regexp + + 5 + + name + constant.character.control.regexp + + 6 + + name + constant.character.escape.backslash.regexp + + + + + include + #regex-character-class + + + + + include + #regex-character-class + + + + regex-character-class + + patterns + + + name + constant.other.character-class.regexp + match + \\[wWsSdDtrnvf]|\. + + + name + constant.character.numeric.regexp + match + \\([0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}) + + + name + constant.character.control.regexp + match + \\c[A-Z] + + + name + constant.character.escape.backslash.regexp + match + \\. + + + + comment + + patterns + + + name + comment.block.documentation.ts + begin + /\*\*(?!/) + beginCaptures + + 0 + + name + punctuation.definition.comment.ts + + + end + \*/ + endCaptures + + 0 + + name + punctuation.definition.comment.ts + + + patterns + + + include + #docblock + + + + + name + comment.block.ts + begin + (/\*)(?:\s*((@)internal)(?=\s|(\*/)))? + beginCaptures + + 1 + + name + punctuation.definition.comment.ts + + 2 + + name + storage.type.internaldeclaration.ts + + 3 + + name + punctuation.decorator.internaldeclaration.ts + + + end + \*/ + endCaptures + + 0 + + name + punctuation.definition.comment.ts + + + + + begin + (^[ \t]+)?((//)(?:\s*((@)internal)(?=\s|$))?) + beginCaptures + + 1 + + name + punctuation.whitespace.comment.leading.ts + + 2 + + name + comment.line.double-slash.ts + + 3 + + name + punctuation.definition.comment.ts + + 4 + + name + storage.type.internaldeclaration.ts + + 5 + + name + punctuation.decorator.internaldeclaration.ts + + + end + (?=$) + contentName + comment.line.double-slash.ts + + + + single-line-comment-consuming-line-ending + + begin + (^[ \t]+)?((//)(?:\s*((@)internal)(?=\s|$))?) + beginCaptures + + 1 + + name + punctuation.whitespace.comment.leading.ts + + 2 + + name + comment.line.double-slash.ts + + 3 + + name + punctuation.definition.comment.ts + + 4 + + name + storage.type.internaldeclaration.ts + + 5 + + name + punctuation.decorator.internaldeclaration.ts + + + end + (?=^) + contentName + comment.line.double-slash.ts + + directives + + name + comment.line.triple-slash.directive.ts + begin + ^(///)\s*(?=<(reference|amd-dependency|amd-module)(\s+(path|types|no-default-lib|lib|name|resolution-mode)\s*=\s*((\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)))+\s*/>\s*$) + beginCaptures + + 1 + + name + punctuation.definition.comment.ts + + + end + (?=$) + patterns + + + name + meta.tag.ts + begin + (<)(reference|amd-dependency|amd-module) + beginCaptures + + 1 + + name + punctuation.definition.tag.directive.ts + + 2 + + name + entity.name.tag.directive.ts + + + end + /> + endCaptures + + 0 + + name + punctuation.definition.tag.directive.ts + + + patterns + + + name + entity.other.attribute-name.directive.ts + match + path|types|no-default-lib|lib|name|resolution-mode + + + name + keyword.operator.assignment.ts + match + = + + + include + #string + + + + + + docblock + + patterns + + + match + (?x) +((@)(?:access|api)) +\s+ +(private|protected|public) +\b + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + constant.language.access-type.jsdoc + + + + + match + (?x) +((@)author) +\s+ +( + [^@\s<>*/] + (?:[^@<>*/]|\*[^/])* +) +(?: + \s* + (<) + ([^>\s]+) + (>) +)? + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + entity.name.type.instance.jsdoc + + 4 + + name + punctuation.definition.bracket.angle.begin.jsdoc + + 5 + + name + constant.other.email.link.underline.jsdoc + + 6 + + name + punctuation.definition.bracket.angle.end.jsdoc + + + + + match + (?x) +((@)borrows) \s+ +((?:[^@\s*/]|\*[^/])+) # <that namepath> +\s+ (as) \s+ # as +((?:[^@\s*/]|\*[^/])+) # <this namepath> + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + entity.name.type.instance.jsdoc + + 4 + + name + keyword.operator.control.jsdoc + + 5 + + name + entity.name.type.instance.jsdoc + + + + + name + meta.example.jsdoc + begin + ((@)example)\s+ + end + (?=@|\*/) + beginCaptures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + + patterns + + + match + ^\s\*\s+ + + + contentName + constant.other.description.jsdoc + begin + \G(<)caption(>) + beginCaptures + + 0 + + name + entity.name.tag.inline.jsdoc + + 1 + + name + punctuation.definition.bracket.angle.begin.jsdoc + + 2 + + name + punctuation.definition.bracket.angle.end.jsdoc + + + end + (</)caption(>)|(?=\*/) + endCaptures + + 0 + + name + entity.name.tag.inline.jsdoc + + 1 + + name + punctuation.definition.bracket.angle.begin.jsdoc + + 2 + + name + punctuation.definition.bracket.angle.end.jsdoc + + + + + match + [^\s@*](?:[^*]|\*[^/])* + captures + + 0 + + name + source.embedded.ts + + + + + + + match + (?x) ((@)kind) \s+ (class|constant|event|external|file|function|member|mixin|module|namespace|typedef) \b + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + constant.language.symbol-type.jsdoc + + + + + match + (?x) +((@)see) +\s+ +(?: + # URL + ( + (?=https?://) + (?:[^\s*]|\*[^/])+ + ) + | + # JSDoc namepath + ( + (?! + # Avoid matching bare URIs (also acceptable as links) + https?:// + | + # Avoid matching {@inline tags}; we match those below + (?:\[[^\[\]]*\])? # Possible description [preceding]{@tag} + {@(?:link|linkcode|linkplain|tutorial)\b + ) + # Matched namepath + (?:[^@\s*/]|\*[^/])+ + ) +) + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + variable.other.link.underline.jsdoc + + 4 + + name + entity.name.type.instance.jsdoc + + + + + match + (?x) +((@)template) +\s+ +# One or more valid identifiers +( + [A-Za-z_$] # First character: non-numeric word character + [\w$.\[\]]* # Rest of identifier + (?: # Possible list of additional identifiers + \s* , \s* + [A-Za-z_$] + [\w$.\[\]]* + )* +) + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + variable.other.jsdoc + + + + + begin + (?x)((@)template)\s+(?={) + beginCaptures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + + end + (?=\s|\*/|[^{}\[\]A-Za-z_$]) + patterns + + + include + #jsdoctype + + + name + variable.other.jsdoc + match + ([A-Za-z_$][\w$.\[\]]*) + + + + + match + (?x) +( + (@) + (?:arg|argument|const|constant|member|namespace|param|var) +) +\s+ +( + [A-Za-z_$] + [\w$.\[\]]* +) + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + variable.other.jsdoc + + + + + begin + ((@)typedef)\s+(?={) + beginCaptures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + + end + (?=\s|\*/|[^{}\[\]A-Za-z_$]) + patterns + + + include + #jsdoctype + + + name + entity.name.type.instance.jsdoc + match + (?:[^@\s*/]|\*[^/])+ + + + + + begin + ((@)(?:arg|argument|const|constant|member|namespace|param|prop|property|var))\s+(?={) + beginCaptures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + + end + (?=\s|\*/|[^{}\[\]A-Za-z_$]) + patterns + + + include + #jsdoctype + + + name + variable.other.jsdoc + match + ([A-Za-z_$][\w$.\[\]]*) + + + name + variable.other.jsdoc + match + (?x) +(\[)\s* +[\w$]+ +(?: + (?:\[\])? # Foo[ ].bar properties within an array + \. # Foo.Bar namespaced parameter + [\w$]+ +)* +(?: + \s* + (=) # [foo=bar] Default parameter value + \s* + ( + # The inner regexes are to stop the match early at */ and to not stop at escaped quotes + (?> + "(?:(?:\*(?!/))|(?:\\(?!"))|[^*\\])*?" | # [foo="bar"] Double-quoted + '(?:(?:\*(?!/))|(?:\\(?!'))|[^*\\])*?' | # [foo='bar'] Single-quoted + \[ (?:(?:\*(?!/))|[^*])*? \] | # [foo=[1,2]] Array literal + (?:(?:\*(?!/))|\s(?!\s*\])|\[.*?(?:\]|(?=\*/))|[^*\s\[\]])* # Everything else + )* + ) +)? +\s*(?:(\])((?:[^*\s]|\*[^\s/])+)?|(?=\*/)) + captures + + 1 + + name + punctuation.definition.optional-value.begin.bracket.square.jsdoc + + 2 + + name + keyword.operator.assignment.jsdoc + + 3 + + name + source.embedded.ts + + 4 + + name + punctuation.definition.optional-value.end.bracket.square.jsdoc + + 5 + + name + invalid.illegal.syntax.jsdoc + + + + + + + begin + (?x) +( + (@) + (?:define|enum|exception|export|extends|lends|implements|modifies + |namespace|private|protected|returns?|satisfies|suppress|this|throws|type + |yields?) +) +\s+(?={) + beginCaptures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + + end + (?=\s|\*/|[^{}\[\]A-Za-z_$]) + patterns + + + include + #jsdoctype + + + + + match + (?x) +( + (@) + (?:alias|augments|callback|constructs|emits|event|fires|exports? + |extends|external|function|func|host|lends|listens|interface|memberof!? + |method|module|mixes|mixin|name|requires|see|this|typedef|uses) +) +\s+ +( + (?: + [^{}@\s*] | \*[^/] + )+ +) + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + entity.name.type.instance.jsdoc + + + + + contentName + variable.other.jsdoc + begin + ((@)(?:default(?:value)?|license|version))\s+(([''"])) + beginCaptures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + variable.other.jsdoc + + 4 + + name + punctuation.definition.string.begin.jsdoc + + + end + (\3)|(?=$|\*/) + endCaptures + + 0 + + name + variable.other.jsdoc + + 1 + + name + punctuation.definition.string.end.jsdoc + + + + + match + ((@)(?:default(?:value)?|license|tutorial|variation|version))\s+([^\s*]+) + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + variable.other.jsdoc + + + + + name + storage.type.class.jsdoc + match + (?x) (@) (?:abstract|access|alias|api|arg|argument|async|attribute|augments|author|beta|borrows|bubbles |callback|chainable|class|classdesc|code|config|const|constant|constructor|constructs|copyright |default|defaultvalue|define|deprecated|desc|description|dict|emits|enum|event|example|exception |exports?|extends|extension(?:_?for)?|external|externs|file|fileoverview|final|fires|for|func |function|generator|global|hideconstructor|host|ignore|implements|implicitCast|inherit[Dd]oc |inner|instance|interface|internal|kind|lends|license|listens|main|member|memberof!?|method |mixes|mixins?|modifies|module|name|namespace|noalias|nocollapse|nocompile|nosideeffects |override|overview|package|param|polymer(?:Behavior)?|preserve|private|prop|property|protected |public|read[Oo]nly|record|require[ds]|returns?|see|since|static|struct|submodule|summary |suppress|template|this|throws|todo|tutorial|type|typedef|unrestricted|uses|var|variation |version|virtual|writeOnce|yields?) \b + captures + + 1 + + name + punctuation.definition.block.tag.jsdoc + + + + + include + #inline-tags + + + match + ((@)(?:[_$[:alpha:]][_$[:alnum:]]*))(?=\s+) + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + + + + + brackets + + patterns + + + begin + { + end + }|(?=\*/) + patterns + + + include + #brackets + + + + + begin + \[ + end + \]|(?=\*/) + patterns + + + include + #brackets + + + + + + inline-tags + + patterns + + + name + constant.other.description.jsdoc + match + (\[)[^\]]+(\])(?={@(?:link|linkcode|linkplain|tutorial)) + captures + + 1 + + name + punctuation.definition.bracket.square.begin.jsdoc + + 2 + + name + punctuation.definition.bracket.square.end.jsdoc + + + + + name + entity.name.type.instance.jsdoc + begin + ({)((@)(?:link(?:code|plain)?|tutorial))\s* + beginCaptures + + 1 + + name + punctuation.definition.bracket.curly.begin.jsdoc + + 2 + + name + storage.type.class.jsdoc + + 3 + + name + punctuation.definition.inline.tag.jsdoc + + + end + }|(?=\*/) + endCaptures + + 0 + + name + punctuation.definition.bracket.curly.end.jsdoc + + + patterns + + + match + \G((?=https?://)(?:[^|}\s*]|\*[/])+)(\|)? + captures + + 1 + + name + variable.other.link.underline.jsdoc + + 2 + + name + punctuation.separator.pipe.jsdoc + + + + + match + \G((?:[^{}@\s|*]|\*[^/])+)(\|)? + captures + + 1 + + name + variable.other.description.jsdoc + + 2 + + name + punctuation.separator.pipe.jsdoc + + + + + + + + jsdoctype + + patterns + + + name + invalid.illegal.type.jsdoc + match + \G{(?:[^}*]|\*[^/}])+$ + + + contentName + entity.name.type.instance.jsdoc + begin + \G({) + beginCaptures + + 0 + + name + entity.name.type.instance.jsdoc + + 1 + + name + punctuation.definition.bracket.curly.begin.jsdoc + + + end + ((}))\s*|(?=\*/) + endCaptures + + 1 + + name + entity.name.type.instance.jsdoc + + 2 + + name + punctuation.definition.bracket.curly.end.jsdoc + + + patterns + + + include + #brackets + + + + + + + + \ No newline at end of file diff --git a/TypeScript.tmTheme b/TypeScript.tmTheme new file mode 100644 index 00000000..aaf28a7f --- /dev/null +++ b/TypeScript.tmTheme @@ -0,0 +1,238 @@ + + + + + name + TypeScript + uuid + 91489F9C-F403-4CF0-993D-EAAF9149E40E + settings + + + scope + storage.modifier, storage.type, keyword.other, keyword.operator.expression, keyword.operator.new, keyword.generator.asterisk, punctuation.definition.template-expression + settings + + vsclassificationtype + keyword + + + + scope + constant.language, variable.language + settings + + vsclassificationtype + keyword + + + + scope + keyword.control, keyword.operator.expression.delete, keyword.other.using, keyword.other.operator, entity.name.operator + settings + + vsclassificationtype + keyword - control + + + + scope + support.class, support.type, entity.name.type, entity.name.namespace, entity.other.attribute, entity.name.scope-resolution, entity.name.class + settings + + vsclassificationtype + type + + + + scope + string, punctuation.definition.string, constant.character + settings + + vsclassificationtype + string + + + + scope + keyword.control.anchor.regexp, keyword.other.back-reference.regexp, keyword.operator.quantifier.regexp, keyword.operator.or.regexp, keyword.operator.negation.regexp, punctuation.definition.group.regexp, punctuation.definition.group.assertion.regexp, meta.assertion.look-ahead.regexp, meta.assertion.negative-look-ahead.regexp, punctuation.definition.group.capture.regexp, punctuation.definition.character-class.regexp, constant.other.character-class.range.regexp + settings + + vsclassificationtype + string + + + + scope + constant.numeric, meta.delimiter.decimal.period.ts, constant.language.nan.ts, constant.language.infinity.ts + settings + + vsclassificationtype + number + + + + scope + keyword.operator, storage.type.function.arrow.ts + settings + + vsclassificationtype + operator + + + + scope + meta.brace.angle.ts, meta.brace.round.ts, meta.brace.square.ts, punctuation, constant.language.import-export-all.ts, meta.delimiter.object.comma.ts + settings + + vsclassificationtype + punctuation + + + + scope + comment, comment.block.ts, comment.line.double-slash.ts, punctuation.definition.comment.ts + settings + + vsclassificationtype + comment + + + + scope + comment.block.documentation.ts, other.meta.jsdoc, other.description.jsdoc + settings + + vsclassificationtype + comment + + + + scope + entity.name.type.instance.jsdoc + settings + + vsclassificationtype + identifier + + + + scope + entity.name.type.class.ts + settings + + vsclassificationtype + class name + + + + scope + entity.name.type.module.ts + settings + + vsclassificationtype + module name + + + + scope + entity.name.type.enum.ts + settings + + vsclassificationtype + enum name + + + + scope + meta.template.expression.ts, entity.other.inherited-class.ts + settings + + vsclassificationtype + identifier + + + + scope + variable, meta.definition.variable.name, support.variable, entity.name.variable, constant.other.placeholder + settings + + vsclassificationtype + local name + + + + scope + entity.name.function, support.function, support.constant.handlebars, source.powershell variable.other.member, entity.name.operator.custom-literal + settings + + vsclassificationtype + method name + + + + scope + variable.language.arguments.ts, support.type.object + settings + + vsclassificationtype + identifier + + + + scope + entity.name.tag.inline, entity.name.tag.directive + settings + + vsclassificationtype + HTML Element Name + + + + scope + entity.other.attribute-name + settings + + vsclassificationtype + HTML Attribute Name + + + + scope + meta.tag string.quoted, meta.tag string.quoted punctuation.definition.string, meta.tag string.quoted + settings + + vsclassificationtype + string + + + + scope + meta.object-literal.key + settings + + vsclassificationtype + parameter name + + + + scope + constant.character.escape + settings + + vsclassificationtype + string - escape character + + + + scope + entity.name.label + settings + + vsclassificationtype + label name + + + + + \ No newline at end of file diff --git a/TypeScriptReact.YAML-tmLanguage b/TypeScriptReact.YAML-tmLanguage index 8109cf3b..f2d203de 100644 --- a/TypeScriptReact.YAML-tmLanguage +++ b/TypeScriptReact.YAML-tmLanguage @@ -1,3 +1,4 @@ +# [PackageDev] target_format: plist, ext: tmLanguage # Similar to TypeScript.YAML-tmLanguage except: # - Remove type assertion (cast.expr.tsx) # - Add JSX expression (HTML-like expression). @@ -7,714 +8,171 @@ scopeName: source.tsx fileTypes: [tsx] uuid: 805375ec-d614-41f5-8993-5843fe63ea82 -patterns: -- include: '#expression' +variables: + # because tsx cannot have cast expression, we can say ] # < typeparam extends + ) | + #possiblyMultilineArrowExpressionBeforeEndOfLine: ({{typeParameters}})?\( + possiblyMultilineArrow: ((<\s*$)|({{possiblyMultilineArrowWithoutTypeParameters}})) # during lookup treat ( followed by line end as arrow + jsxTagOrAtrributeIdentifier: '[_$[:alpha:]][-_$[:alnum:].]*' + jsxTagNamespace: (?:({{jsxTagOrAtrributeIdentifier}})(?) + jsxClosingTag: () + jsxTagStart: (<){{jsxTagName}}(?=((<\s*)|(\s+))(?!\?)|\/?>) + jsxTagStartLookahead: (?={{jsxTagStart}}) + jsxLookBehindInExpression: (?:*]|&&|\|\||\?|\*\/|{{lookBehindAwait}}|{{lookBehindReturn}}|{{lookBehindDefault}}|{{lookBehindYield}}|^)\s* repository: - var-expr: - name: meta.var.expr.tsx - begin: (?]|var|type|function|class|interface) - patterns: - - include: '#type-parameters' - - include: '#type' - - name: keyword.operator.comparison.tsx - match: '=\s*' - - enum-declaration: - name: meta.enum.declaration.tsx - match: (?:\b(const)\s+)?\b(enum)\s+([a-zA-Z_$][\w$]*) - captures: - '1': { name: storage.modifier.tsx} - '2': { name: storage.type.tsx } - '3': { name: entity.name.class.tsx } - - object-declaration: - name: meta.declaration.object.tsx - begin: '\b(?:(export)\s+)?\b(?:(abstract)\s+)?\b(? - - include: '#object-body' - - object-name: - name: meta.object.name.tsx - match: '[a-zA-Z_$][\w$]*' - captures: - '0': { name: 'entity.name.class.tsx' } - - object-heritage: - name: meta.object.heritage.tsx - begin: '(?:\b(extends|implements)\b)' - beginCaptures: - '1': { name: keyword.other.tsx } - end: (?=\{) - endCaptures: - '1': { name: brace.curly.tsx } - patterns: - - include: '#comment' - - include: '#object-heritage' - - include: '#type-parameters' - - include: '#object-heritage-type' + - include: '#jsx' - object-heritage-type: - name: meta.object.heritage.parent.tsx - match: '(?:\b([a-zA-Z_$][\w$]*)\b)' - captures: - '1': { name: support.type.tsx } + # Overrides: - object-body: - name: meta.object.body.tsx - begin: \{ - beginCaptures: - '0': { name: meta.brace.curly.tsx } - end: \} - endCaptures: - '0': { name: meta.brace.curly.tsx } + # We need to override this to make sure cast is not matched from typescript + # We can safely include jsx because thats the first rule matched anyways so it wont impact at all + cast: patterns: - - include: "#string" - - include: '#comment' - - include: '#field-declaration' - - include: '#method-declaration' - - include: '#indexer-declaration' - - include: '#type-annotation' - - include: '#variable-initializer' - - include: '#access-modifier' - - include: '#static-modifier' - - include: '#property-accessor' - - type-object: - name: meta.object.type.tsx - begin: \{ - beginCaptures: - '0': { name: meta.brace.curly.tsx } - end: \} - endCaptures: - '0': { name: meta.brace.curly.tsx } - patterns: - - include: '#comment' - - include: '#field-declaration' - - include: '#method-declaration' - - include: '#indexer-declaration' - - include: '#type-annotation' + - include: '#jsx' - field-declaration: - name: meta.field.declaration.tsx - begin: (?])|,)) # look ahead is not type parameter of arrow + {{jsxTagStartLookahead}} + end: (?!{{jsxTagStart}}) + patterns: + - include: '#jsx-tag' + + jsx-tag: + name: meta.tag.tsx + begin: '{{jsxTagStartLookahead}}' + end: (/>)|(?:{{jsxClosingTag}}) + endCaptures: + '1': { name: punctuation.definition.tag.end.tsx } + '2': { name: punctuation.definition.tag.begin.tsx } + '3': { name: entity.name.tag.namespace.tsx } + '4': { name: punctuation.separator.namespace.tsx } + '5': { name: entity.name.tag.tsx } + '6': { name: support.class.component.tsx } + '7': { name: punctuation.definition.tag.end.tsx } + patterns: + - begin: '{{jsxTagStart}}' + beginCaptures: + '1': { name: punctuation.definition.tag.begin.tsx } + '2': { name: entity.name.tag.namespace.tsx } + '3': { name: punctuation.separator.namespace.tsx } + '4': { name: entity.name.tag.tsx } + '5': { name: support.class.component.tsx } + end: (?=[/]?>) + patterns: + - include: '#comment' + - include: '#type-arguments' + - include: '#jsx-tag-attributes' + - begin: (>) + beginCaptures: + '1': { name: punctuation.definition.tag.end.tsx } + end: (?=])|(?<=[\}>\]\)]|[a-zA-Z_$])\s*(?=\{) - patterns: - - include: '#expression-operator' - - include: '#type' - - include: '#string' - - include: '#comment' - - type: - name: meta.type.tsx - patterns: - - include: '#type-primitive' - - include: '#type-parameters' - - include: '#type-tuple' - - include: '#type-object' - - include: '#type-operator' - - include: '#type-paren-or-function-type-parameters' - - include: '#type-function-return-type' - - include: '#type-name' - - function-type-parameters: - name: meta.function.type.parameter.tsx - begin: \( beginCaptures: - '0': { name: meta.brace.round.tsx } - end: \) + '0': { name: punctuation.section.embedded.begin.tsx } endCaptures: - '0': { name: meta.brace.round.tsx } - patterns: - - include: '#comment' - - include: '#parameter-name' - - include: '#type-annotation' - - include: '#variable-initializer' - - type-primitive: - name: meta.type.primitive.tsx - match: '\b(string|number|boolean|symbol|any|void)\b' - captures: - '1': { name: support.type.tsx } - - # Parenthesis can contain either types and function parameters - # (number | string) or (param: number, param2: string) - # and it can be nested, for example - # (number | (param: number, param2: string) => void) - type-paren-or-function-type-parameters: - name: meta.type.paren.cover.tsx - begin: '(?:\b(new)\b)?\s*\(' - beginCaptures: - '1': { name: keyword.control.tsx } - end: '\)' - patterns: - - include: '#comment' - - include: '#type' - - include: '#function-type-parameters' - - await-modifier: - name: storage.modifier.tsx - match: '\bawait\b' - - type-operator: - name: keyword.operator.type.tsx - match: '[.|]' - - type-function-return-type: - name: meta.type.function.return.tsx - begin: '=>' - beginCaptures: - '0': { name: keyword.operator.tsx } - end: (?=\s*[,\)\{=;>]|//|$) - patterns: - - include: '#type' - - type-tuple: - name: meta.type.tuple.tsx - begin: \[ - beginCaptures: - '0': { name: meta.brace.square.tsx } - end: \] - endCaptures: - '0': { name: meta.brace.square.tsx } - patterns: - - include: '#type' - - include: '#comment' - - type-name: - name: meta.type.name.tsx - match: '[a-zA-Z_$][.\w$]*' - captures: - '1': { name: entity.name.type.tsx } - - type-parameters: - name: meta.type.parameters.tsx - begin: '([a-zA-Z_$][\w$]*)?(<)' - beginCaptures: - '1': { name: entity.name.type.tsx } - '2': { name: meta.brace.angle.tsx } - end: '(?=$)|(>)' - endCaptures: - '2': { name: meta.brace.angle.tsx } - patterns: - - name: keyword.other.tsx - match: '\b(extends)\b' - - include: '#comment' - - include: '#type' - - variable-initializer: - begin: (=) - beginCaptures: - '1': { name: keyword.operator.comparison.tsx } - end: (?=$|[,);=]) - patterns: - - include: '#expression' - - expression: - name: meta.expression.tsx - patterns: - - include: '#jsx' - - include: '#for-in-simple' - - include: '#string' - - include: '#regex' - - include: '#template' - - include: '#comment' - - include: '#literal' - - include: '#paren-expression' - - include: '#var-expr' - - include: '#declaration' - - include: '#new-expr' - - include: '#switch-statement' - - include: '#block' - - include: '#import-operator' - - include: '#expression-operator' - - include: '#imply-operator' - - include: '#relational-operator' - - include: '#arithmetic-operator' - - include: '#logic-operator' - - include: '#assignment-operator' - - include: '#storage-keyword' - - include: '#type-primitive' - - include: '#function-call' - - include: '#case-clause' - - include: '#control-statement' - - switch-expression: - name: switch-expression.expr.tsx - begin: \b(switch)\b\s*\( - beginCaptures: - '1': { name: keyword.control.tsx } - end: \) + '0': { name: punctuation.section.embedded.end.tsx } patterns: - include: '#expression' - switch-block: - name: switch-block.expr.tsx - begin: '{' - end: (?=\}) - patterns: - - include: '#expression' - - case-clause: - name: case-clause.expr.tsx - begin: '(? - - import-operator: - name: keyword.control.import.include.tsx - match: \b(import|from)\b - - arithmetic-operator: - name: keyword.operator.arithmetic.tsx - match: \*|/|\-\-|\-|\+\+|\+|% - - relational-operator: - - name: keyword.operator.comparison.tsx - match: ===|!==|==|!=|<=|>=|<>|=|<|> - - assignment-operator: - name: keyword.operator.assignment.tsx - match: <<=|>>>=|>>=|\*=|(?) patterns: - - include: '#jsx-tag-attribute-name' - - include: '#jsx-tag-attribute-assignment' - - include: '#jsx-string-double-quoted' - - include: '#jsx-string-single-quoted' - - include: '#jsx-evaluated-code' + - include: '#comment' + - include: '#jsx-tag-attribute-name' + - include: '#jsx-tag-attribute-assignment' + - include: '#jsx-string-double-quoted' + - include: '#jsx-string-single-quoted' + - include: '#jsx-evaluated-code' + - include: '#jsx-tag-attributes-illegal' jsx-tag-attribute-name: - name: meta.tag.attribute-name.tsx - match: >- + match: |- (?x) \s* - ([_$a-zA-Z][-$\w]*) + (?:({{jsxTagOrAtrributeIdentifier}})(:))? + ([_$[:alpha:]][-_$[:alnum:]]*) (?=\s|=|/?>|/\*|//) captures: - '1': {name: entity.other.attribute-name.tsx} + '1': {name: entity.other.attribute-name.namespace.tsx} + '2': {name: punctuation.separator.namespace.tsx} + '3': {name: entity.other.attribute-name.tsx} jsx-tag-attribute-assignment: name: keyword.operator.assignment.tsx @@ -742,101 +200,8 @@ repository: patterns: - include: '#jsx-entities' - jsx-entities: - patterns: - - name: constant.character.entity.tsx - match: (&)([a-zA-Z0-9]+|#[0-9]+|#x[0-9a-fA-F]+)(;) - captures: - '1': {name: punctuation.definition.entity.tsx} - '3': {name: punctuation.definition.entity.tsx} - - name: invalid.illegal.bad-ampersand.tsx - match: '&' - - jsx-evaluated-code: - name: meta.brace.curly.tsx - begin: '{' - end: '}' - beginCaptures: - '0': {name: punctuation.definition.brace.curly.start.tsx} - endCaptures: - '0': {name: punctuation.definition.brace.curly.end.tsx} - patterns: - - include: '#expression' - jsx-tag-attributes-illegal: name: invalid.illegal.attribute.tsx match: \S+ - jsx-tag-without-attributes: - name: tag.without-attributes.tsx - begin: (<)([_$a-zA-Z][-$\w.]*(?) - end: () - beginCaptures: - '1': {name: punctuation.definition.tag.begin.tsx} - '2': {name: entity.name.tag.tsx} - '3': {name: punctuation.definition.tag.end.tsx} - endCaptures: - '1': {name: punctuation.definition.tag.begin.tsx} - '2': {name: entity.name.tag.tsx} - '3': {name: punctuation.definition.tag.end.tsx} - patterns: - - include: '#jsx-children' - - jsx-tag-open: - name: tag.open.tsx - begin: >- - (?x) - (<) - ([_$a-zA-Z][-$\w.]*(?) - end: (/?>) - beginCaptures: - '1': {name: punctuation.definition.tag.begin.tsx} - '2': {name: entity.name.tag.tsx} - endCaptures: - '1': {name: punctuation.definition.tag.end.tsx} - patterns: - - include: '#comment' - - include: '#jsx-tag-attributes' - - include: '#jsx-tag-attributes-illegal' - - jsx-tag-close: - name: tag.close.tsx - begin: () - beginCaptures: - '1': {name: punctuation.definition.tag.begin.tsx} - '2': {name: entity.name.tag.tsx} - endCaptures: - '1': {name: punctuation.definition.tag.end.tsx} - patterns: - - include: '#comment' - - jsx-tag-invalid: - name: invalid.illegal.tag.incomplete.tsx - match: <\s*> - - jsx-children: - patterns: - - include: '#jsx-tag-without-attributes' - - include: '#jsx-tag-open' - - include: '#jsx-tag-close' - - include: '#jsx-tag-invalid' - - include: '#jsx-evaluated-code' - - include: '#jsx-entities' - - jsx: - name: meta.jsx.tsx - patterns: - - include: '#jsx-tag-without-attributes' - - include: '#jsx-tag-open' - - include: '#jsx-tag-close' - - include: '#jsx-tag-invalid' - - - name: meta.jsx.children.tsx - begin: (?<=(?:'|"|})>) - end: (?= - - fileTypes - - tsx - - name - TypeScriptReact - patterns - - - include - #expression - - - repository - - access-modifier - - match - \b(public|protected|private)\b - name - storage.modifier.tsx - - arithmetic-operator - - match - \*|/|\-\-|\-|\+\+|\+|% - name - keyword.operator.arithmetic.tsx - - array-literal - - begin - \[ - beginCaptures - - 0 - - name - meta.brace.square.tsx - - - end - \] - endCaptures - - 0 - - name - meta.brace.square.tsx - - - name - meta.array.literal.tsx - patterns - - - include - #expression - - - - assignment-operator - - match - <<=|>>>=|>>=|\*=|(?<!\()/=|%=|\+=|\-=|&=|\^= - name - keyword.operator.assignment.tsx - - await-modifier - - match - \bawait\b - name - storage.modifier.tsx - - block - - begin - \{ - beginCaptures - - 0 - - name - meta.brace.curly.tsx - - - end - \} - endCaptures - - 0 - - name - meta.brace.curly.tsx - - - name - meta.block.tsx - patterns - - - include - #object-member - - - include - #expression - - - - boolean-literal - - match - \b(false|true)\b - name - constant.language.boolean.tsx - - case-clause - - begin - (?<!\.)\b(case|default(?=:))\b - beginCaptures - - 1 - - name - keyword.control.tsx - - - end - : - name - case-clause.expr.tsx - patterns - - - include - #expression-type - - - - comment - - name - comment.tsx - patterns - - - include - #comment-block-doc - - - include - #comment-block - - - include - #comment-line - - - - comment-block - - begin - /\* - end - \*/ - name - comment.block.tsx - - comment-block-doc - - begin - /\*\*(?!/) - end - \*/ - name - comment.block.documentation.tsx - - comment-line - - match - (//).*$\n? - name - comment.line.tsx - - control-statement - - match - (?<!\.)\b(break|catch|continue|debugger|declare|do|else|finally|for|if|return|switch|throw|try|while|with|super|case|default|yield)\b - name - keyword.control.tsx - - decl-block - - begin - \{ - beginCaptures - - 0 - - name - meta.brace.curly.tsx - - - end - \} - endCaptures - - 0 - - name - meta.brace.curly.tsx - - - name - meta.decl.block.tsx - patterns - - - include - #expression - - - - declaration - - name - meta.declaration.tsx - patterns - - - include - #function-declaration - - - include - #object-declaration - - - include - #type-declaration - - - include - #enum-declaration - - - - enum-declaration - - captures - - 1 - - name - storage.modifier.tsx - - 2 - - name - storage.type.tsx - - 3 - - name - entity.name.class.tsx - - - match - (?:\b(const)\s+)?\b(enum)\s+([a-zA-Z_$][\w$]*) - name - meta.enum.declaration.tsx - - expression - - name - meta.expression.tsx - patterns - - - include - #jsx - - - include - #for-in-simple - - - include - #string - - - include - #regex - - - include - #template - - - include - #comment - - - include - #literal - - - include - #paren-expression - - - include - #var-expr - - - include - #declaration - - - include - #new-expr - - - include - #switch-statement - - - include - #block - - - include - #import-operator - - - include - #expression-operator - - - include - #imply-operator - - - include - #relational-operator - - - include - #arithmetic-operator - - - include - #logic-operator - - - include - #assignment-operator - - - include - #storage-keyword - - - include - #type-primitive - - - include - #function-call - - - include - #case-clause - - - include - #control-statement - - - - expression-operator - - match - \b(delete|in|instanceof|new|typeof|as|is|of)\b - name - keyword.others.tsx - - expression-type - - name - meta.expression.tsx - patterns - - - include - #string - - - include - #regex - - - include - #template - - - include - #comment - - - include - #literal - - - include - #paren-expression - - - include - #ternary-expression - - - include - #import-operator - - - include - #expression-operator - - - include - #imply-operator - - - include - #relational-operator - - - include - #arithmetic-operator - - - include - #logic-operator - - - include - #assignment-operator - - - include - #type-primitive - - - include - #function-call - - - - field-declaration - - begin - (?<!\()\s*((?:\b[a-zA-Z_$][\w$]*)|(?:\'[^']*\')|(?:\"[^"]*\"))\s*(\?\s*)?(?=(=|:)) - beginCaptures - - 1 - - name - variable.tsx - - 2 - - name - keyword.others.tsx - - - end - (?=\}|;|,|$)|(?<=\}) - name - meta.field.declaration.tsx - patterns - - - include - #expression - - - - for-in-simple - - captures - - 1 - - name - storage.type.tsx - - 3 - - name - keyword.others.tsx - - - match - (?<=\()\s*\b(var|let|const)\s+([a-zA-Z_$][\w$]*)\s+(in|of)\b - name - forin.expr.tsx - - function-call - - name - functioncall.expr.tsx - patterns - - - include - #await-modifier - - - include - #type-parameters - - - include - #paren-expression - - - - function-declaration - - begin - \b(?:(export)\s+)?(?:(async)\s+)?(function\b)(?:\s+([a-zA-Z_$][\w$]*))?\s* - beginCaptures - - 1 - - name - storage.type.tsx - - 2 - - name - storage.modifier.tsx - - 3 - - name - storage.type.function.tsx - - 4 - - name - entity.name.function.tsx - - - end - (?=;|\})|(?<=\}) - name - meta.function.tsx - patterns - - - include - #comment - - - include - #type-parameters - - - include - #function-type-parameters - - - include - #return-type - - - include - #function-overload-declaration - - - include - #decl-block - - - - function-overload-declaration - - captures - - 1 - - name - storage.type.tsx - - 2 - - name - storage.type.function.tsx - - 3 - - name - entity.name.function.tsx - - - match - \b(?:(export)\s+)?(function\b)(?:\s+([a-zA-Z_$][\w$]*))?\s* - name - meta.function.overload.tsx - - function-type-parameters - - begin - \( - beginCaptures - - 0 - - name - meta.brace.round.tsx - - - end - \) - endCaptures - - 0 - - name - meta.brace.round.tsx - - - name - meta.function.type.parameter.tsx - patterns - - - include - #comment - - - include - #parameter-name - - - include - #type-annotation - - - include - #variable-initializer - - - - imply-operator - - match - => - name - keyword.operator.tsx - - import-operator - - match - \b(import|from)\b - name - keyword.control.import.include.tsx - - indexer-declaration - - begin - \[ - beginCaptures - - 0 - - name - meta.brace.square.tsx - - - end - (\])\s*(\?\s*)?|$ - endCaptures - - 1 - - name - meta.brace.square.tsx - - 2 - - name - keyword.others.tsx - - - name - meta.indexer.declaration.tsx - patterns - - - include - #type-annotation - - - include - #indexer-parameter - - - include - #expression - - - - indexer-parameter - - captures - - 1 - - name - variable.parameter.tsx - - - match - ([a-zA-Z_$][\w$]*)(?=\:) - name - meta.indexer.parameter.tsx - - jsx - - name - meta.jsx.tsx - patterns - - - include - #jsx-tag-without-attributes - - - include - #jsx-tag-open - - - include - #jsx-tag-close - - - include - #jsx-tag-invalid - - - begin - (?<=(?:'|"|})>) - end - (?=</) - name - meta.jsx.children.tsx - patterns - - - include - #jsx-children - - - - - - jsx-children - - patterns - - - include - #jsx-tag-without-attributes - - - include - #jsx-tag-open - - - include - #jsx-tag-close - - - include - #jsx-tag-invalid - - - include - #jsx-evaluated-code - - - include - #jsx-entities - - - - jsx-entities - - patterns - - - captures - - 1 - - name - punctuation.definition.entity.tsx - - 3 - - name - punctuation.definition.entity.tsx - - - match - (&)([a-zA-Z0-9]+|#[0-9]+|#x[0-9a-fA-F]+)(;) - name - constant.character.entity.tsx - - - match - & - name - invalid.illegal.bad-ampersand.tsx - - - - jsx-evaluated-code - - begin - { - beginCaptures - - 0 - - name - punctuation.definition.brace.curly.start.tsx - - - end - } - endCaptures - - 0 - - name - punctuation.definition.brace.curly.end.tsx - - - name - meta.brace.curly.tsx - patterns - - - include - #expression - - - - jsx-string-double-quoted - - begin - " - beginCaptures - - 0 - - name - punctuation.definition.string.begin.tsx - - - end - " - endCaptures - - 0 - - name - punctuation.definition.string.end.tsx - - - name - string.quoted.double.tsx - patterns - - - include - #jsx-entities - - - - jsx-string-single-quoted - - begin - ' - beginCaptures - - 0 - - name - punctuation.definition.string.begin.tsx - - - end - ' - endCaptures - - 0 - - name - punctuation.definition.string.end.tsx - - - name - string.quoted.single.tsx - patterns - - - include - #jsx-entities - - - - jsx-tag-attribute-assignment - - match - =(?=\s*(?:'|"|{|/\*|//|\n)) - name - keyword.operator.assignment.tsx - - jsx-tag-attribute-name - - captures - - 1 - - name - entity.other.attribute-name.tsx - - - match - (?x) + + name + TypeScriptReact + scopeName + source.tsx + fileTypes + + tsx + + uuid + 805375ec-d614-41f5-8993-5843fe63ea82 + patterns + + + include + #directives + + + include + #statements + + + include + #shebang + + + repository + + shebang + + name + comment.line.shebang.tsx + match + \A(#!).*(?=$) + captures + + 1 + + name + punctuation.definition.comment.tsx + + + + statements + + patterns + + + include + #declaration + + + include + #control-statement + + + include + #after-operator-block-as-object-literal + + + include + #decl-block + + + include + #label + + + include + #expression + + + include + #punctuation-semicolon + + + include + #string + + + include + #comment + + + + declaration + + patterns + + + include + #decorator + + + include + #var-expr + + + include + #function-declaration + + + include + #class-declaration + + + include + #interface-declaration + + + include + #enum-declaration + + + include + #namespace-declaration + + + include + #type-alias-declaration + + + include + #import-equals-declaration + + + include + #import-declaration + + + include + #export-declaration + + + name + storage.modifier.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(declare|export)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + + control-statement + + patterns + + + include + #switch-statement + + + include + #for-loop + + + name + keyword.control.trycatch.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(catch|finally|throw|try)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(break|continue|goto)\s+([_$[:alpha:]][_$[:alnum:]]*)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + captures + + 1 + + name + keyword.control.loop.tsx + + 2 + + name + entity.name.label.tsx + + + + + name + keyword.control.loop.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(break|continue|do|goto|while)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(return)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 0 + + name + keyword.control.flow.tsx + + + end + (?=[;}]|$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #expression + + + + + name + keyword.control.switch.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default|switch)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + include + #if-statement + + + name + keyword.control.conditional.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(else|if)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.control.with.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(with)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.control.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(package)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.other.debugger.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(debugger)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + + label + + patterns + + + begin + ([_$[:alpha:]][_$[:alnum:]]*)\s*(:)(?=\s*\{) + beginCaptures + + 1 + + name + entity.name.label.tsx + + 2 + + name + punctuation.separator.label.tsx + + + end + (?<=\}) + patterns + + + include + #decl-block + + + + + match + ([_$[:alpha:]][_$[:alnum:]]*)\s*(:) + captures + + 1 + + name + entity.name.label.tsx + + 2 + + name + punctuation.separator.label.tsx + + + + + + expression + + patterns + + + include + #expressionWithoutIdentifiers + + + include + #identifiers + + + include + #expressionPunctuations + + + + expressionWithoutIdentifiers + + patterns + + + include + #jsx + + + include + #string + + + include + #regex + + + include + #comment + + + include + #function-expression + + + include + #class-expression + + + include + #arrow-function + + + include + #paren-expression-possibly-arrow + + + include + #cast + + + include + #ternary-expression + + + include + #new-expr + + + include + #instanceof-expr + + + include + #object-literal + + + include + #expression-operators + + + include + #function-call + + + include + #literal + + + include + #support-objects + + + include + #paren-expression + + + + expressionPunctuations + + patterns + + + include + #punctuation-comma + + + include + #punctuation-accessor + + + + decorator + + name + meta.decorator.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))\@ + beginCaptures + + 0 + + name + punctuation.decorator.tsx + + + end + (?=\s) + patterns + + + include + #expression + + + + var-expr + + patterns + + + name + meta.var.expr.tsx + begin + (?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) + end + (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=^|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|((?<!^let|[^\._$[:alnum:]]let|^var|[^\._$[:alnum:]]var)(?=\s*$))) + patterns + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(var|let)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s* + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.type.tsx + + + end + (?=\S) + + + include + #destructuring-variable + + + include + #var-single-variable + + + include + #variable-initializer + + + include + #comment + + + begin + (,)\s*(?=$|\/\/) + beginCaptures + + 1 + + name + punctuation.separator.comma.tsx + + + end + (?<!,)(((?==|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$))) + patterns + + + include + #single-line-comment-consuming-line-ending + + + include + #comment + + + include + #destructuring-variable + + + include + #var-single-variable + + + include + #punctuation-comma + + + + + include + #punctuation-comma + + + + + name + meta.var.expr.tsx + begin + (?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.type.tsx + + + end + (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=^|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|((?<!^const|[^\._$[:alnum:]]const)(?=\s*$))) + patterns + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(const(?!\s+enum\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s* + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.type.tsx + + + end + (?=\S) + + + include + #destructuring-const + + + include + #var-single-const + + + include + #variable-initializer + + + include + #comment + + + begin + (,)\s*(?=$|\/\/) + beginCaptures + + 1 + + name + punctuation.separator.comma.tsx + + + end + (?<!,)(((?==|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$))) + patterns + + + include + #single-line-comment-consuming-line-ending + + + include + #comment + + + include + #destructuring-const + + + include + #var-single-const + + + include + #punctuation-comma + + + + + include + #punctuation-comma + + + + + name + meta.var.expr.tsx + begin + (?=(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b((?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.type.tsx + + + end + (?!(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b((?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))((?=;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|((?<!^using|[^\._$[:alnum:]]using|^await\s+using|[^\._$[:alnum:]]await\s+using)(?=\s*$))) + patterns + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b((?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s* + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.type.tsx + + + end + (?=\S) + + + include + #var-single-const + + + include + #variable-initializer + + + include + #comment + + + begin + (,)\s*((?!\S)|(?=\/\/)) + beginCaptures + + 1 + + name + punctuation.separator.comma.tsx + + + end + (?<!,)(((?==|;|}|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|^\s*$))|((?<=\S)(?=\s*$))) + patterns + + + include + #single-line-comment-consuming-line-ending + + + include + #comment + + + include + #var-single-const + + + include + #punctuation-comma + + + + + include + #punctuation-comma + + + + + + var-single-variable + + patterns + + + name + meta.var-single-variable.expr.tsx + begin + (?x)([_$[:alpha:]][_$[:alnum:]]*)(\!)?(?=\s* +# function assignment | +(=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | +( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends +) | +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +)) | +# typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => +(:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) +)) | +(:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) | +(:\s*((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | +(:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | +( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends +) | +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +))) + beginCaptures + + 1 + + name + meta.definition.variable.tsx entity.name.function.tsx + + 2 + + name + keyword.operator.definiteassignment.tsx + + + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))) + patterns + + + include + #var-single-variable-type-annotation + + + + + name + meta.var-single-variable.expr.tsx + begin + ([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])(\!)? + beginCaptures + + 1 + + name + meta.definition.variable.tsx variable.other.constant.tsx + + 2 + + name + keyword.operator.definiteassignment.tsx + + + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))) + patterns + + + include + #var-single-variable-type-annotation + + + + + name + meta.var-single-variable.expr.tsx + begin + ([_$[:alpha:]][_$[:alnum:]]*)(\!)? + beginCaptures + + 1 + + name + meta.definition.variable.tsx variable.other.readwrite.tsx + + 2 + + name + keyword.operator.definiteassignment.tsx + + + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))) + patterns + + + include + #var-single-variable-type-annotation + + + + + + var-single-const + + patterns + + + name + meta.var-single-variable.expr.tsx + begin + (?x)([_$[:alpha:]][_$[:alnum:]]*)(?=\s* +# function assignment | +(=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | +( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends +) | +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +)) | +# typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => +(:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) +)) | +(:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) | +(:\s*((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | +(:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | +( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends +) | +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +))) + beginCaptures + + 1 + + name + meta.definition.variable.tsx variable.other.constant.tsx entity.name.function.tsx + + + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))) + patterns + + + include + #var-single-variable-type-annotation + + + + + name + meta.var-single-variable.expr.tsx + begin + ([_$[:alpha:]][_$[:alnum:]]*) + beginCaptures + + 1 + + name + meta.definition.variable.tsx variable.other.constant.tsx + + + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)|(;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))) + patterns + + + include + #var-single-variable-type-annotation + + + + + + var-single-variable-type-annotation + + patterns + + + include + #type-annotation + + + include + #string + + + include + #comment + + + + destructuring-variable + + patterns + + + name + meta.object-binding-pattern-variable.tsx + begin + (?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\{) + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)) + patterns + + + include + #object-binding-pattern + + + include + #type-annotation + + + include + #comment + + + + + name + meta.array-binding-pattern-variable.tsx + begin + (?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\[) + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)) + patterns + + + include + #array-binding-pattern + + + include + #type-annotation + + + include + #comment + + + + + + destructuring-const + + patterns + + + name + meta.object-binding-pattern-variable.tsx + begin + (?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\{) + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)) + patterns + + + include + #object-binding-pattern-const + + + include + #type-annotation + + + include + #comment + + + + + name + meta.array-binding-pattern-variable.tsx + begin + (?<!=|:|^of|[^\._$[:alnum:]]of|^in|[^\._$[:alnum:]]in)\s*(?=\[) + end + (?=$|^|[;,=}]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)) + patterns + + + include + #array-binding-pattern-const + + + include + #type-annotation + + + include + #comment + + + + + + object-binding-element + + patterns + + + include + #comment + + + begin + (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:)) + end + (?=,|\}) + patterns + + + include + #object-binding-element-propertyName + + + include + #binding-element + + + + + include + #object-binding-pattern + + + include + #destructuring-variable-rest + + + include + #variable-initializer + + + include + #punctuation-comma + + + + object-binding-element-const + + patterns + + + include + #comment + + + begin + (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:)) + end + (?=,|\}) + patterns + + + include + #object-binding-element-propertyName + + + include + #binding-element-const + + + + + include + #object-binding-pattern-const + + + include + #destructuring-variable-rest-const + + + include + #variable-initializer + + + include + #punctuation-comma + + + + object-binding-element-propertyName + + begin + (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:)) + end + (:) + endCaptures + + 0 + + name + punctuation.destructuring.tsx + + + patterns + + + include + #string + + + include + #array-literal + + + include + #numeric-literal + + + name + variable.object.property.tsx + match + ([_$[:alpha:]][_$[:alnum:]]*) + + + + binding-element + + patterns + + + include + #comment + + + include + #string + + + include + #numeric-literal + + + include + #regex + + + include + #object-binding-pattern + + + include + #array-binding-pattern + + + include + #destructuring-variable-rest + + + include + #variable-initializer + + + + binding-element-const + + patterns + + + include + #comment + + + include + #string + + + include + #numeric-literal + + + include + #regex + + + include + #object-binding-pattern-const + + + include + #array-binding-pattern-const + + + include + #destructuring-variable-rest-const + + + include + #variable-initializer + + + + destructuring-variable-rest + + match + (?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + keyword.operator.rest.tsx + + 2 + + name + meta.definition.variable.tsx variable.other.readwrite.tsx + + + + destructuring-variable-rest-const + + match + (?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + keyword.operator.rest.tsx + + 2 + + name + meta.definition.variable.tsx variable.other.constant.tsx + + + + object-binding-pattern + + begin + (?:(\.\.\.)\s*)?(\{) + beginCaptures + + 1 + + name + keyword.operator.rest.tsx + + 2 + + name + punctuation.definition.binding-pattern.object.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.object.tsx + + + patterns + + + include + #object-binding-element + + + + object-binding-pattern-const + + begin + (?:(\.\.\.)\s*)?(\{) + beginCaptures + + 1 + + name + keyword.operator.rest.tsx + + 2 + + name + punctuation.definition.binding-pattern.object.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.object.tsx + + + patterns + + + include + #object-binding-element-const + + + + array-binding-pattern + + begin + (?:(\.\.\.)\s*)?(\[) + beginCaptures + + 1 + + name + keyword.operator.rest.tsx + + 2 + + name + punctuation.definition.binding-pattern.array.tsx + + + end + \] + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.array.tsx + + + patterns + + + include + #binding-element + + + include + #punctuation-comma + + + + array-binding-pattern-const + + begin + (?:(\.\.\.)\s*)?(\[) + beginCaptures + + 1 + + name + keyword.operator.rest.tsx + + 2 + + name + punctuation.definition.binding-pattern.array.tsx + + + end + \] + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.array.tsx + + + patterns + + + include + #binding-element-const + + + include + #punctuation-comma + + + + parameter-name + + patterns + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|protected|private|readonly)\s+(?=(override|public|protected|private|readonly)\s+) + captures + + 1 + + name + storage.modifier.tsx + + + + + match + (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s* +# function assignment | +(=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | +( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends +) | +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +)) | +# typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => +(:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) +)) | +(:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) | +(:\s*((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | +(:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | +( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends +) | +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +))) + captures + + 1 + + name + storage.modifier.tsx + + 2 + + name + keyword.operator.rest.tsx + + 3 + + name + entity.name.function.tsx variable.language.this.tsx + + 4 + + name + entity.name.function.tsx + + 5 + + name + keyword.operator.optional.tsx + + + + + match + (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??) + captures + + 1 + + name + storage.modifier.tsx + + 2 + + name + keyword.operator.rest.tsx + + 3 + + name + variable.parameter.tsx variable.language.this.tsx + + 4 + + name + variable.parameter.tsx + + 5 + + name + keyword.operator.optional.tsx + + + + + + destructuring-parameter + + patterns + + + name + meta.parameter.object-binding-pattern.tsx + begin + (?<!=|:)\s*(?:(\.\.\.)\s*)?(\{) + beginCaptures + + 1 + + name + keyword.operator.rest.tsx + + 2 + + name + punctuation.definition.binding-pattern.object.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.object.tsx + + + patterns + + + include + #parameter-object-binding-element + + + + + name + meta.paramter.array-binding-pattern.tsx + begin + (?<!=|:)\s*(?:(\.\.\.)\s*)?(\[) + beginCaptures + + 1 + + name + keyword.operator.rest.tsx + + 2 + + name + punctuation.definition.binding-pattern.array.tsx + + + end + \] + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.array.tsx + + + patterns + + + include + #parameter-binding-element + + + include + #punctuation-comma + + + + + + parameter-object-binding-element + + patterns + + + include + #comment + + + begin + (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(:)) + end + (?=,|\}) + patterns + + + include + #object-binding-element-propertyName + + + include + #parameter-binding-element + + + include + #paren-expression + + + + + include + #parameter-object-binding-pattern + + + include + #destructuring-parameter-rest + + + include + #variable-initializer + + + include + #punctuation-comma + + + + parameter-binding-element + + patterns + + + include + #comment + + + include + #string + + + include + #numeric-literal + + + include + #regex + + + include + #parameter-object-binding-pattern + + + include + #parameter-array-binding-pattern + + + include + #destructuring-parameter-rest + + + include + #variable-initializer + + + + destructuring-parameter-rest + + match + (?:(\.\.\.)\s*)?([_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + keyword.operator.rest.tsx + + 2 + + name + variable.parameter.tsx + + + + parameter-object-binding-pattern + + begin + (?:(\.\.\.)\s*)?(\{) + beginCaptures + + 1 + + name + keyword.operator.rest.tsx + + 2 + + name + punctuation.definition.binding-pattern.object.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.object.tsx + + + patterns + + + include + #parameter-object-binding-element + + + + parameter-array-binding-pattern + + begin + (?:(\.\.\.)\s*)?(\[) + beginCaptures + + 1 + + name + keyword.operator.rest.tsx + + 2 + + name + punctuation.definition.binding-pattern.array.tsx + + + end + \] + endCaptures + + 0 + + name + punctuation.definition.binding-pattern.array.tsx + + + patterns + + + include + #parameter-binding-element + + + include + #punctuation-comma + + + + field-declaration + + name + meta.field.declaration.tsx + begin + (?x)(?<!\()(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s+)?(?=\s*((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|(\#?[_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(?:(?:(\?)|(\!))\s*)?(=|:|;|,|\}|$)) + beginCaptures + + 1 + + name + storage.modifier.tsx + + + end + (?x)(?=\}|;|,|$|(^(?!\s*((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|(\#?[_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(?:(?:(\?)|(\!))\s*)?(=|:|;|,|$))))|(?<=\}) + patterns + + + include + #variable-initializer + + + include + #type-annotation + + + include + #string + + + include + #array-literal + + + include + #numeric-literal + + + include + #comment + + + match + (?x)(\#?[_$[:alpha:]][_$[:alnum:]]*)(?:(\?)|(\!))?(?=\s*\s* +# function assignment | +(=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | +( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends +) | +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +)) | +# typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => +(:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) +)) | +(:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) | +(:\s*((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | +(:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | +( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends +) | +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +))) + captures + + 1 + + name + meta.definition.property.tsx entity.name.function.tsx + + 2 + + name + keyword.operator.optional.tsx + + 3 + + name + keyword.operator.definiteassignment.tsx + + + + + name + meta.definition.property.tsx variable.object.property.tsx + match + \#?[_$[:alpha:]][_$[:alnum:]]* + + + name + keyword.operator.optional.tsx + match + \? + + + name + keyword.operator.definiteassignment.tsx + match + \! + + + + variable-initializer + + patterns + + + begin + (?<!=|!)(=)(?!=)(?=\s*\S)(?!\s*.*=>\s*$) + beginCaptures + + 1 + + name + keyword.operator.assignment.tsx + + + end + (?=$|^|[,);}\]]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+)) + patterns + + + include + #expression + + + + + begin + (?<!=|!)(=)(?!=) + beginCaptures + + 1 + + name + keyword.operator.assignment.tsx + + + end + (?=[,);}\]]|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(of|in)\s+))|(?=^\s*$)|(?<![\|\&\+\-\*\/])(?<=\S)(?<!=)(?=\s*$) + patterns + + + include + #expression + + + + + + function-declaration + + name + meta.function.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s* + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.modifier.async.tsx + + 4 + + name + storage.type.function.tsx + + 5 + + name + keyword.generator.asterisk.tsx + + 6 + + name + meta.definition.function.tsx entity.name.function.tsx + + + end + (?=;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))|(?<=\}) + patterns + + + include + #function-name + + + include + #function-body + + + + function-expression + + name + meta.function.expression.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(async)\s+)?(function\b)(?:\s*(\*))?(?:(?:\s+|(?<=\*))([_$[:alpha:]][_$[:alnum:]]*))?\s* + beginCaptures + + 1 + + name + storage.modifier.async.tsx + + 2 + + name + storage.type.function.tsx + + 3 + + name + keyword.generator.asterisk.tsx + + 4 + + name + meta.definition.function.tsx entity.name.function.tsx + + + end + (?=;)|(?<=\}) + patterns + + + include + #function-name + + + include + #single-line-comment-consuming-line-ending + + + include + #function-body + + + + function-name + + name + meta.definition.function.tsx entity.name.function.tsx + match + [_$[:alpha:]][_$[:alnum:]]* + + function-body + + patterns + + + include + #comment + + + include + #type-parameters + + + include + #function-parameters + + + include + #return-type + + + include + #type-function-return-type + + + include + #decl-block + + + name + keyword.generator.asterisk.tsx + match + \* + + + + method-declaration + + patterns + + + name + meta.method.declaration.tsx + begin + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?\s*\b(constructor)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + storage.modifier.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.modifier.tsx + + 4 + + name + storage.modifier.async.tsx + + 5 + + name + storage.type.tsx + + + end + (?=\}|;|,|$)|(?<=\}) + patterns + + + include + #method-declaration-name + + + include + #function-body + + + + + name + meta.method.declaration.tsx + begin + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:(?:\s*\b(new)\b(?!:)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|(?:(\*)\s*)?)(?=\s*((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + beginCaptures + + 1 + + name + storage.modifier.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.modifier.tsx + + 4 + + name + storage.modifier.async.tsx + + 5 + + name + keyword.operator.new.tsx + + 6 + + name + keyword.generator.asterisk.tsx + + + end + (?=\}|;|,|$)|(?<=\}) + patterns + + + include + #method-declaration-name + + + include + #function-body + + + + + name + meta.method.declaration.tsx + begin + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(override)\s+)?(?:\b(public|private|protected)\s+)?(?:\b(abstract)\s+)?(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=\s*(((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + beginCaptures + + 1 + + name + storage.modifier.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.modifier.tsx + + 4 + + name + storage.modifier.async.tsx + + 5 + + name + storage.type.property.tsx + + 6 + + name + keyword.generator.asterisk.tsx + + + end + (?=\}|;|,|$)|(?<=\}) + patterns + + + include + #method-declaration-name + + + include + #function-body + + + + + + object-literal-method-declaration + + name + meta.method.declaration.tsx + begin + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=\s*(((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + beginCaptures + + 1 + + name + storage.modifier.async.tsx + + 2 + + name + storage.type.property.tsx + + 3 + + name + keyword.generator.asterisk.tsx + + + end + (?=\}|;|,)|(?<=\}) + patterns + + + include + #method-declaration-name + + + include + #function-body + + + begin + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(async)\s+)?(?:\b(get|set)\s+)?(?:(\*)\s*)?(?=\s*(((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??))\s*((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + beginCaptures + + 1 + + name + storage.modifier.async.tsx + + 2 + + name + storage.type.property.tsx + + 3 + + name + keyword.generator.asterisk.tsx + + + end + (?=\(|\<) + patterns + + + include + #method-declaration-name + + + + + + method-declaration-name + + begin + (?x)(?=((\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))|([_$[:alpha:]][_$[:alnum:]]*)|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))\s*(\??)\s*[\(\<]) + end + (?=\(|\<) + patterns + + + include + #string + + + include + #array-literal + + + include + #numeric-literal + + + name + meta.definition.method.tsx entity.name.function.tsx + match + [_$[:alpha:]][_$[:alnum:]]* + + + name + keyword.operator.optional.tsx + match + \? + + + + arrow-function + + patterns + + + name + meta.arrow.tsx + match + (?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync)\s+)?([_$[:alpha:]][_$[:alnum:]]*)\s*(?==>) + captures + + 1 + + name + storage.modifier.async.tsx + + 2 + + name + variable.parameter.tsx + + + + + name + meta.arrow.tsx + begin + (?x) (?: + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(\basync) +)? ((?<![})!\]])\s* + (?= + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | +( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends +) | +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + ) +) + beginCaptures + + 1 + + name + storage.modifier.async.tsx + + + end + (?==>|\{|(^\s*(export|function|class|interface|let|var|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|const|import|enum|namespace|module|type|abstract|declare)\s+)) + patterns + + + include + #comment + + + include + #type-parameters + + + include + #function-parameters + + + include + #arrow-return-type + + + include + #possibly-arrow-return-type + + + + + name + meta.arrow.tsx + begin + => + beginCaptures + + 0 + + name + storage.type.function.arrow.tsx + + + end + ((?<=\}|\S)(?<!=>)|((?!\{)(?=\S)))(?!\/[\/\*]) + patterns + + + include + #single-line-comment-consuming-line-ending + + + include + #decl-block + + + include + #expression + + + + + + indexer-declaration + + name + meta.indexer.declaration.tsx + begin + (?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)\s*)?\s*(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s*(?=:) + beginCaptures + + 1 + + name + storage.modifier.tsx + + 2 + + name + meta.brace.square.tsx + + 3 + + name + variable.parameter.tsx + + + end + (\])\s*(\?\s*)?|$ + endCaptures + + 1 + + name + meta.brace.square.tsx + + 2 + + name + keyword.operator.optional.tsx + + + patterns + + + include + #type-annotation + + + + indexer-mapped-type-declaration + + name + meta.indexer.mappedtype.declaration.tsx + begin + (?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))([+-])?(readonly)\s*)?\s*(\[)\s*([_$[:alpha:]][_$[:alnum:]]*)\s+(in)\s+ + beginCaptures + + 1 + + name + keyword.operator.type.modifier.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + meta.brace.square.tsx + + 4 + + name + entity.name.type.tsx + + 5 + + name + keyword.operator.expression.in.tsx + + + end + (\])([+-])?\s*(\?\s*)?|$ + endCaptures + + 1 + + name + meta.brace.square.tsx + + 2 + + name + keyword.operator.type.modifier.tsx + + 3 + + name + keyword.operator.optional.tsx + + + patterns + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+ + captures + + 1 + + name + keyword.control.as.tsx + + + + + include + #type + + + + function-parameters + + name + meta.parameters.tsx + begin + \( + beginCaptures + + 0 + + name + punctuation.definition.parameters.begin.tsx + + + end + \) + endCaptures + + 0 + + name + punctuation.definition.parameters.end.tsx + + + patterns + + + include + #function-parameters-body + + + + function-parameters-body + + patterns + + + include + #comment + + + include + #string + + + include + #decorator + + + include + #destructuring-parameter + + + include + #parameter-name + + + include + #parameter-type-annotation + + + include + #variable-initializer + + + name + punctuation.separator.parameter.tsx + match + , + + + + class-declaration + + name + meta.class.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(?:(abstract)\s+)?\b(class)\b(?=\s+|/[/*]) + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.modifier.tsx + + 4 + + name + storage.type.class.tsx + + + end + (?<=\}) + patterns + + + include + #class-declaration-or-expression-patterns + + + + class-expression + + name + meta.class.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(class)\b(?=\s+|[<{]|\/[\/*]) + beginCaptures + + 1 + + name + storage.modifier.tsx + + 2 + + name + storage.type.class.tsx + + + end + (?<=\}) + patterns + + + include + #class-declaration-or-expression-patterns + + + + class-declaration-or-expression-patterns + + patterns + + + include + #comment + + + include + #class-or-interface-heritage + + + match + [_$[:alpha:]][_$[:alnum:]]* + captures + + 0 + + name + entity.name.type.class.tsx + + + + + include + #type-parameters + + + include + #class-or-interface-body + + + + interface-declaration + + name + meta.interface.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(?:(abstract)\s+)?\b(interface)\b(?=\s+|/[/*]) + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.modifier.tsx + + 4 + + name + storage.type.interface.tsx + + + end + (?<=\}) + patterns + + + include + #comment + + + include + #class-or-interface-heritage + + + match + [_$[:alpha:]][_$[:alnum:]]* + captures + + 0 + + name + entity.name.type.interface.tsx + + + + + include + #type-parameters + + + include + #class-or-interface-body + + + + class-or-interface-heritage + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:\b(extends|implements)\b)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + storage.modifier.tsx + + + end + (?=\{) + patterns + + + include + #comment + + + include + #class-or-interface-heritage + + + include + #type-parameters + + + include + #expressionWithoutIdentifiers + + + match + ([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))(?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s*\??\.\s*[_$[:alpha:]][_$[:alnum:]]*)*\s*) + captures + + 1 + + name + entity.name.type.module.tsx + + 2 + + name + punctuation.accessor.tsx + + 3 + + name + punctuation.accessor.optional.tsx + + + + + match + ([_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + entity.other.inherited-class.tsx + + + + + include + #expressionPunctuations + + + + class-or-interface-body + + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.tsx + + + patterns + + + include + #comment + + + include + #decorator + + + begin + (?<=:)\s* + end + (?=\s|[;),}\]:\-\+]|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #expression + + + + + include + #method-declaration + + + include + #indexer-declaration + + + include + #field-declaration + + + include + #string + + + include + #type-annotation + + + include + #variable-initializer + + + include + #access-modifier + + + include + #property-accessor + + + include + #async-modifier + + + include + #after-operator-block-as-object-literal + + + include + #decl-block + + + include + #expression + + + include + #punctuation-comma + + + include + #punctuation-semicolon + + + + access-modifier + + name + storage.modifier.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(abstract|declare|override|public|protected|private|readonly|static)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + property-accessor + + name + storage.type.property.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(accessor|get|set)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + async-modifier + + name + storage.modifier.async.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(async)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + enum-declaration + + name + meta.enum.declaration.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?(?:\b(const)\s+)?\b(enum)\s+([_$[:alpha:]][_$[:alnum:]]*) + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.modifier.tsx + + 4 + + name + storage.type.enum.tsx + + 5 + + name + entity.name.type.enum.tsx + + + end + (?<=\}) + patterns + + + include + #comment + + + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.tsx + + + patterns + + + include + #comment + + + begin + ([_$[:alpha:]][_$[:alnum:]]*) + beginCaptures + + 0 + + name + variable.other.enummember.tsx + + + end + (?=,|\}|$) + patterns + + + include + #comment + + + include + #variable-initializer + + + + + begin + (?=((\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)|(\[([^\[\]]|\[[^\[\]]*\])+\]))) + end + (?=,|\}|$) + patterns + + + include + #string + + + include + #array-literal + + + include + #comment + + + include + #variable-initializer + + + + + include + #punctuation-comma + + + + + + namespace-declaration + + name + meta.namespace.declaration.tsx + begin + (?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(namespace|module)\s+(?=[_$[:alpha:]"'`])) + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.type.namespace.tsx + + + end + (?<=\})|(?=;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #comment + + + include + #string + + + name + entity.name.type.module.tsx + match + ([_$[:alpha:]][_$[:alnum:]]*) + + + include + #punctuation-accessor + + + include + #decl-block + + + + type-alias-declaration + + name + meta.type.declaration.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(type)\b\s+([_$[:alpha:]][_$[:alnum:]]*)\s* + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + storage.type.type.tsx + + 4 + + name + entity.name.type.alias.tsx + + + end + (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #comment + + + include + #type-parameters + + + begin + (=)\s*(intrinsic)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + keyword.operator.assignment.tsx + + 2 + + name + keyword.control.intrinsic.tsx + + + end + (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #type + + + + + begin + (=)\s* + beginCaptures + + 1 + + name + keyword.operator.assignment.tsx + + + end + (?=\}|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #type + + + + + + import-equals-declaration + + patterns + + + name + meta.import-equals.external.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(import)(?:\s+(type))?\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(require)\s*(\() + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + keyword.control.import.tsx + + 4 + + name + keyword.control.type.tsx + + 5 + + name + variable.other.readwrite.alias.tsx + + 6 + + name + keyword.operator.assignment.tsx + + 7 + + name + keyword.control.require.tsx + + 8 + + name + meta.brace.round.tsx + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.tsx + + + patterns + + + include + #comment + + + include + #string + + + + + name + meta.import-equals.internal.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(import)(?:\s+(type))?\s+([_$[:alpha:]][_$[:alnum:]]*)\s*(=)\s*(?!require\b) + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + keyword.control.import.tsx + + 4 + + name + keyword.control.type.tsx + + 5 + + name + variable.other.readwrite.alias.tsx + + 6 + + name + keyword.operator.assignment.tsx + + + end + (?=;|$|^) + patterns + + + include + #single-line-comment-consuming-line-ending + + + include + #comment + + + match + ([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]]))) + captures + + 1 + + name + entity.name.type.module.tsx + + 2 + + name + punctuation.accessor.tsx + + 3 + + name + punctuation.accessor.optional.tsx + + + + + name + variable.other.readwrite.tsx + match + ([_$[:alpha:]][_$[:alnum:]]*) + + + + + + import-declaration + + name + meta.import.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(\bexport)\s+)?(?:(\bdeclare)\s+)?\b(import)(?:\s+(type)(?!\s+from))?(?!\s*[:\(])(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + storage.modifier.tsx + + 3 + + name + keyword.control.import.tsx + + 4 + + name + keyword.control.type.tsx + + + end + (?<!^import|[^\._$[:alnum:]]import)(?=;|$|^) + patterns + + + include + #single-line-comment-consuming-line-ending + + + include + #comment + + + include + #string + + + begin + (?<=^import|[^\._$[:alnum:]]import)(?!\s*["']) + end + \bfrom\b + endCaptures + + 0 + + name + keyword.control.from.tsx + + + patterns + + + include + #import-export-declaration + + + + + include + #import-export-declaration + + + + export-declaration + + patterns + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)\s+(as)\s+(namespace)\s+([_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + keyword.control.as.tsx + + 3 + + name + storage.type.namespace.tsx + + 4 + + name + entity.name.type.module.tsx + + + + + name + meta.export.default.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:\s+(type))?(?:(?:\s*(=))|(?:\s+(default)(?=\s+))) + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + keyword.control.type.tsx + + 3 + + name + keyword.operator.assignment.tsx + + 4 + + name + keyword.control.default.tsx + + + end + (?=$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #interface-declaration + + + include + #expression + + + + + name + meta.export.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(export)(?:\s+(type))?\b(?!(\$)|(\s*:))((?=\s*[\{*])|((?=\s*[_$[:alpha:]][_$[:alnum:]]*(\s|,))(?!\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b))) + beginCaptures + + 1 + + name + keyword.control.export.tsx + + 2 + + name + keyword.control.type.tsx + + + end + (?=$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #import-export-declaration + + + + + + import-export-declaration + + patterns + + + include + #comment + + + include + #string + + + include + #import-export-block + + + name + keyword.control.from.tsx + match + \bfrom\b + + + include + #import-export-assert-clause + + + include + #import-export-clause + + + + import-export-assert-clause + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(with)|(assert))\s*(\{) + beginCaptures + + 1 + + name + keyword.control.with.tsx + + 2 + + name + keyword.control.assert.tsx + + 3 + + name + punctuation.definition.block.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.tsx + + + patterns + + + include + #comment + + + include + #string + + + name + meta.object-literal.key.tsx + match + (?:[_$[:alpha:]][_$[:alnum:]]*)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:) + + + name + punctuation.separator.key-value.tsx + match + : + + + + import-export-block + + name + meta.block.tsx + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.tsx + + + patterns + + + include + #import-export-clause + + + + import-export-clause + + patterns + + + include + #comment + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(?:(\btype)\s+)?(?:(\bdefault)|(\*)|(\b[_$[:alpha:]][_$[:alnum:]]*)|((\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))))\s+(as)\s+(?:(default(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|([_$[:alpha:]][_$[:alnum:]]*)|((\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))) + captures + + 1 + + name + keyword.control.type.tsx + + 2 + + name + keyword.control.default.tsx + + 3 + + name + constant.language.import-export-all.tsx + + 4 + + name + variable.other.readwrite.tsx + + 5 + + name + string.quoted.alias.tsx + + 12 + + name + keyword.control.as.tsx + + 13 + + name + keyword.control.default.tsx + + 14 + + name + variable.other.readwrite.alias.tsx + + 15 + + name + string.quoted.alias.tsx + + + + + include + #punctuation-comma + + + name + constant.language.import-export-all.tsx + match + \* + + + name + keyword.control.default.tsx + match + \b(default)\b + + + match + (?:(\btype)\s+)?(?:([_$[:alpha:]][_$[:alnum:]]*)|((\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))) + captures + + 1 + + name + keyword.control.type.tsx + + 2 + + name + variable.other.readwrite.alias.tsx + + 3 + + name + string.quoted.alias.tsx + + + + + + switch-statement + + name + switch-statement.expr.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bswitch\s*\() + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.tsx + + + patterns + + + include + #comment + + + name + switch-expression.expr.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(switch)\s*(\() + beginCaptures + + 1 + + name + keyword.control.switch.tsx + + 2 + + name + meta.brace.round.tsx + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.tsx + + + patterns + + + include + #expression + + + + + name + switch-block.expr.tsx + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.tsx + + + end + (?=\}) + patterns + + + name + case-clause.expr.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(case|default(?=:))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + keyword.control.switch.tsx + + + end + (?=:) + patterns + + + include + #expression + + + + + begin + (:)\s*(\{) + beginCaptures + + 1 + + name + case-clause.expr.tsx punctuation.definition.section.case-statement.tsx + + 2 + + name + meta.block.tsx punctuation.definition.block.tsx + + + end + \} + endCaptures + + 0 + + name + meta.block.tsx punctuation.definition.block.tsx + + + contentName + meta.block.tsx + patterns + + + include + #statements + + + + + match + (:) + captures + + 0 + + name + case-clause.expr.tsx punctuation.definition.section.case-statement.tsx + + + + + include + #statements + + + + + + for-loop + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))for(?=((\s+|(\s*\/\*([^\*]|(\*[^\/]))*\*\/\s*))await)?\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)?(\()) + beginCaptures + + 0 + + name + keyword.control.loop.tsx + + + end + (?<=\)) + patterns + + + include + #comment + + + name + keyword.control.loop.tsx + match + await + + + begin + \( + beginCaptures + + 0 + + name + meta.brace.round.tsx + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.tsx + + + patterns + + + include + #var-expr + + + include + #expression + + + include + #punctuation-semicolon + + + + + + if-statement + + patterns + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?=\bif\s*(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))\s*(?!\{)) + end + (?=;|$|\}) + patterns + + + include + #comment + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(if)\s*(\() + beginCaptures + + 1 + + name + keyword.control.conditional.tsx + + 2 + + name + meta.brace.round.tsx + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.tsx + + + patterns + + + include + #expression + + + + + name + string.regexp.tsx + begin + (?<=\))\s*\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/([dgimsuvy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$])) + beginCaptures + + 0 + + name + punctuation.definition.string.begin.tsx + + + end + (/)([dgimsuvy]*) + endCaptures + + 1 + + name + punctuation.definition.string.end.tsx + + 2 + + name + keyword.other.tsx + + + patterns + + + include + #regexp + + + + + include + #statements + + + + + + decl-block + + name + meta.block.tsx + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.tsx + + + patterns + + + include + #statements + + + + after-operator-block-as-object-literal + + name + meta.objectliteral.tsx + begin + (?<!\+\+|--)(?<=[:=(,\[?+!>]|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^yield|[^\._$[:alnum:]]yield|^throw|[^\._$[:alnum:]]throw|^in|[^\._$[:alnum:]]in|^of|[^\._$[:alnum:]]of|^typeof|[^\._$[:alnum:]]typeof|&&|\|\||\*)\s*(\{) + beginCaptures + + 1 + + name + punctuation.definition.block.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.tsx + + + patterns + + + include + #object-member + + + + object-literal + + name + meta.objectliteral.tsx + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.tsx + + + patterns + + + include + #object-member + + + + object-member + + patterns + + + include + #comment + + + include + #object-literal-method-declaration + + + name + meta.object.member.tsx meta.object-literal.key.tsx + begin + (?=\[) + end + (?=:)|((?<=[\]])(?=\s*[\(\<])) + patterns + + + include + #comment + + + include + #array-literal + + + + + name + meta.object.member.tsx meta.object-literal.key.tsx + begin + (?=[\'\"\`]) + end + (?=:)|((?<=[\'\"\`])(?=((\s*[\(\<,}])|(\s+(as|satisifies)\s+)))) + patterns + + + include + #comment + + + include + #string + + + + + name + meta.object.member.tsx meta.object-literal.key.tsx + begin + (?x)(?=(\b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$))|(\b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$))|((?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$))) + end + (?=:)|(?=\s*([\(\<,}])|(\s+as|satisifies\s+)) + patterns + + + include + #comment + + + include + #numeric-literal + + + + + name + meta.method.declaration.tsx + begin + (?<=[\]\'\"\`])(?=\s*[\(\<]) + end + (?=\}|;|,)|(?<=\}) + patterns + + + include + #function-body + + + + + name + meta.object.member.tsx + match + (?![_$[:alpha:]])([[:digit:]]+)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:) + captures + + 0 + + name + meta.object-literal.key.tsx + + 1 + + name + constant.numeric.decimal.tsx + + + + + name + meta.object.member.tsx + match + (?x)(?:([_$[:alpha:]][_$[:alnum:]]*)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:(\s*\/\*([^\*]|(\*[^\/]))*\*\/)*\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | +( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends +) | +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +))) + captures + + 0 + + name + meta.object-literal.key.tsx + + 1 + + name + entity.name.function.tsx + + + + + name + meta.object.member.tsx + match + (?:[_$[:alpha:]][_$[:alnum:]]*)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:) + captures + + 0 + + name + meta.object-literal.key.tsx + + + + + name + meta.object.member.tsx + begin + \.\.\. + beginCaptures + + 0 + + name + keyword.operator.spread.tsx + + + end + (?=,|\}) + patterns + + + include + #expression + + + + + name + meta.object.member.tsx + match + ([_$[:alpha:]][_$[:alnum:]]*)\s*(?=,|\}|$|\/\/|\/\*) + captures + + 1 + + name + variable.other.readwrite.tsx + + + + + name + meta.object.member.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+(const)(?=\s*([,}]|$)) + captures + + 1 + + name + keyword.control.as.tsx + + 2 + + name + storage.modifier.tsx + + + + + name + meta.object.member.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(as)|(satisfies))\s+ + beginCaptures + + 1 + + name + keyword.control.as.tsx + + 2 + + name + keyword.control.satisfies.tsx + + + end + (?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|^|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as|satisifies)\s+)) + patterns + + + include + #type + + + + + name + meta.object.member.tsx + begin + (?=[_$[:alpha:]][_$[:alnum:]]*\s*=) + end + (?=,|\}|$|\/\/|\/\*) + patterns + + + include + #expression + + + + + name + meta.object.member.tsx + begin + : + beginCaptures + + 0 + + name + meta.object-literal.key.tsx punctuation.separator.key-value.tsx + + + end + (?=,|\}) + patterns + + + begin + (?<=:)\s*(async)?(?=\s*(<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))) + beginCaptures + + 1 + + name + storage.modifier.async.tsx + + + end + (?<=\)) + patterns + + + include + #type-parameters + + + begin + \( + beginCaptures + + 0 + + name + meta.brace.round.tsx + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.tsx + + + patterns + + + include + #expression-inside-possibly-arrow-parens + + + + + + + begin + (?<=:)\s*(async)?\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))) + beginCaptures + + 1 + + name + storage.modifier.async.tsx + + 2 + + name + meta.brace.round.tsx + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.tsx + + + patterns + + + include + #expression-inside-possibly-arrow-parens + + + + + begin + (?<=:)\s*(async)?\s*(?=\<\s*$) + beginCaptures + + 1 + + name + storage.modifier.async.tsx + + + end + (?<=\>) + patterns + + + include + #type-parameters + + + + + begin + (?<=\>)\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))) + beginCaptures + + 1 + + name + meta.brace.round.tsx + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.tsx + + + patterns + + + include + #expression-inside-possibly-arrow-parens + + + + + include + #possibly-arrow-return-type + + + include + #expression + + + + + include + #punctuation-comma + + + include + #decl-block + + + + ternary-expression + + begin + (?!\?\.\s*[^[:digit:]])(\?)(?!\?) + beginCaptures + + 1 + + name + keyword.operator.ternary.tsx + + + end + \s*(:) + endCaptures + + 1 + + name + keyword.operator.ternary.tsx + + + patterns + + + include + #expression + + + + function-call + + patterns + + + begin + (?=(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\()) + end + (?<=\))(?!(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\()) + patterns + + + name + meta.function-call.tsx + begin + (?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*)) + end + (?=\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?\()) + patterns + + + include + #function-call-target + + + + + include + #comment + + + include + #function-call-optionals + + + include + #type-arguments + + + include + #paren-expression + + + + + begin + (?=(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))(<\s*[\{\[\(]\s*$)) + end + (?<=\>)(?!(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))(<\s*[\{\[\(]\s*$)) + patterns + + + name + meta.function-call.tsx + begin + (?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*)) + end + (?=(<\s*[\{\[\(]\s*$)) + patterns + + + include + #function-call-target + + + + + include + #comment + + + include + #function-call-optionals + + + include + #type-arguments + + + + + + function-call-target + + patterns + + + include + #support-function-call-identifiers + + + name + entity.name.function.tsx + match + (\#?[_$[:alpha:]][_$[:alnum:]]*) + + + + function-call-optionals + + patterns + + + name + meta.function-call.tsx punctuation.accessor.optional.tsx + match + \?\. + + + name + meta.function-call.tsx keyword.operator.definiteassignment.tsx + match + \! + + + + support-function-call-identifiers + + patterns + + + include + #literal + + + include + #support-objects + + + include + #object-identifiers + + + include + #punctuation-accessor + + + name + keyword.operator.expression.import.tsx + match + (?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*[\(]\s*[\"\'\`])) + + + + new-expr + + name + new.expr.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + keyword.operator.new.tsx + + + end + (?<=\))|(?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(])))) + patterns + + + include + #expression + + + + instanceof-expr + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(instanceof)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 1 + + name + keyword.operator.expression.instanceof.tsx + + + end + (?<=\))|(?=[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|(===|!==|==|!=)|(([\&\~\^\|]\s*)?[_$[:alpha:]][_$[:alnum:]]*\s+instanceof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))function((\s+[_$[:alpha:]][_$[:alnum:]]*)|(\s*[\(])))) + patterns + + + include + #type + + + + paren-expression-possibly-arrow + + patterns + + + begin + (?<=[(=,])\s*(async)?(?=\s*((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))) + beginCaptures + + 1 + + name + storage.modifier.async.tsx + + + end + (?<=\)) + patterns + + + include + #paren-expression-possibly-arrow-with-typeparameters + + + + + begin + (?<=[(=,]|=>|^return|[^\._$[:alnum:]]return)\s*(async)?(?=\s*((((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\()|(<)|((<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)))\s*$) + beginCaptures + + 1 + + name + storage.modifier.async.tsx + + + end + (?<=\)) + patterns + + + include + #paren-expression-possibly-arrow-with-typeparameters + + + + + include + #possibly-arrow-return-type + + + + paren-expression-possibly-arrow-with-typeparameters + + patterns + + + include + #type-parameters + + + begin + \( + beginCaptures + + 0 + + name + meta.brace.round.tsx + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.tsx + + + patterns + + + include + #expression-inside-possibly-arrow-parens + + + + + + expression-inside-possibly-arrow-parens + + patterns + + + include + #expressionWithoutIdentifiers + + + include + #comment + + + include + #string + + + include + #decorator + + + include + #destructuring-parameter + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|protected|private|readonly)\s+(?=(override|public|protected|private|readonly)\s+) + captures + + 1 + + name + storage.modifier.tsx + + + + + match + (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s* +# function assignment | +(=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | +( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends +) | +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +)) | +# typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => +(:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) +)) | +(:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) | +(:\s*((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | +(:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | +( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends +) | +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +))) + captures + + 1 + + name + storage.modifier.tsx + + 2 + + name + keyword.operator.rest.tsx + + 3 + + name + entity.name.function.tsx variable.language.this.tsx + + 4 + + name + entity.name.function.tsx + + 5 + + name + keyword.operator.optional.tsx + + + + + match + (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(override|public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s*(\??)(?=\s*[:,]|$) + captures + + 1 + + name + storage.modifier.tsx + + 2 + + name + keyword.operator.rest.tsx + + 3 + + name + variable.parameter.tsx variable.language.this.tsx + + 4 + + name + variable.parameter.tsx + + 5 + + name + keyword.operator.optional.tsx + + + + + include + #type-annotation + + + include + #variable-initializer + + + name + punctuation.separator.parameter.tsx + match + , + + + include + #identifiers + + + include + #expressionPunctuations + + + + paren-expression + + begin + \( + beginCaptures + + 0 + + name + meta.brace.round.tsx + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.tsx + + + patterns + + + include + #expression + + + + cast + + patterns + + + include + #jsx + + + + expression-operators + + patterns + + + name + keyword.control.flow.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(await)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(yield)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?=\s*\/\*([^\*]|(\*[^\/]))*\*\/\s*\*) + beginCaptures + + 1 + + name + keyword.control.flow.tsx + + + end + \* + endCaptures + + 0 + + name + keyword.generator.asterisk.tsx + + + patterns + + + include + #comment + + + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(yield)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?:\s*(\*))? + captures + + 1 + + name + keyword.control.flow.tsx + + 2 + + name + keyword.generator.asterisk.tsx + + + + + name + keyword.operator.expression.delete.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))delete(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.operator.expression.in.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))in(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?!\() + + + name + keyword.operator.expression.of.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))of(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?!\() + + + name + keyword.operator.expression.instanceof.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))instanceof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.operator.new.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))new(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + include + #typeof-operator + + + name + keyword.operator.expression.void.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))void(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as)\s+(const)(?=\s*($|[;,:})\]])) + captures + + 1 + + name + keyword.control.as.tsx + + 2 + + name + storage.modifier.tsx + + + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(as)|(satisfies))\s+ + beginCaptures + + 1 + + name + keyword.control.as.tsx + + 2 + + name + keyword.control.satisfies.tsx + + + end + (?=^|[;),}\]:?\-\+\>]|\|\||\&\&|\!\=\=|$|((?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(as|satisfies)\s+)|(\s+\<)) + patterns + + + include + #type + + + + + name + keyword.operator.spread.tsx + match + \.\.\. + + + name + keyword.operator.assignment.compound.tsx + match + \*=|(?<!\()/=|%=|\+=|\-= + + + name + keyword.operator.assignment.compound.bitwise.tsx + match + \&=|\^=|<<=|>>=|>>>=|\|= + + + name + keyword.operator.bitwise.shift.tsx + match + <<|>>>|>> + + + name + keyword.operator.comparison.tsx + match + ===|!==|==|!= + + + name + keyword.operator.relational.tsx + match + <=|>=|<>|<|> + + + match + (?<=[_$[:alnum:]])(\!)\s*(?:(/=)|(?:(/)(?![/*]))) + captures + + 1 + + name + keyword.operator.logical.tsx + + 2 + + name + keyword.operator.assignment.compound.tsx + + 3 + + name + keyword.operator.arithmetic.tsx + + + + + name + keyword.operator.logical.tsx + match + \!|&&|\|\||\?\? + + + name + keyword.operator.bitwise.tsx + match + \&|~|\^|\| + + + name + keyword.operator.assignment.tsx + match + \= + + + name + keyword.operator.decrement.tsx + match + -- + + + name + keyword.operator.increment.tsx + match + \+\+ + + + name + keyword.operator.arithmetic.tsx + match + %|\*|/|-|\+ + + + begin + (?<=[_$[:alnum:])\]])\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)+(?:(/=)|(?:(/)(?![/*])))) + end + (?:(/=)|(?:(/)(?!\*([^\*]|(\*[^\/]))*\*\/))) + endCaptures + + 1 + + name + keyword.operator.assignment.compound.tsx + + 2 + + name + keyword.operator.arithmetic.tsx + + + patterns + + + include + #comment + + + + + match + (?<=[_$[:alnum:])\]])\s*(?:(/=)|(?:(/)(?![/*]))) + captures + + 1 + + name + keyword.operator.assignment.compound.tsx + + 2 + + name + keyword.operator.arithmetic.tsx + + + + + + typeof-operator + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))typeof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + beginCaptures + + 0 + + name + keyword.operator.expression.typeof.tsx + + + end + (?=[,);}\]=>:&|{\?]|(extends\s+)|$|;|^\s*$|(?:^\s*(?:abstract|async|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|break|case|catch|class|const|continue|declare|do|else|enum|export|finally|function|for|goto|if|import|interface|let|module|namespace|switch|return|throw|try|type|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|var|while)\b)) + patterns + + + include + #type-arguments + + + include + #expression + + + + literal + + patterns + + + include + #numeric-literal + + + include + #boolean-literal + + + include + #null-literal + + + include + #undefined-literal + + + include + #numericConstant-literal + + + include + #array-literal + + + include + #this-literal + + + include + #super-literal + + + + array-literal + + name + meta.array.literal.tsx + begin + \s*(\[) + beginCaptures + + 1 + + name + meta.brace.square.tsx + + + end + \] + endCaptures + + 0 + + name + meta.brace.square.tsx + + + patterns + + + include + #expression + + + include + #punctuation-comma + + + + numeric-literal + + patterns + + + name + constant.numeric.hex.tsx + match + \b(?<!\$)0(?:x|X)[0-9a-fA-F][0-9a-fA-F_]*(n)?\b(?!\$) + captures + + 1 + + name + storage.type.numeric.bigint.tsx + + + + + name + constant.numeric.binary.tsx + match + \b(?<!\$)0(?:b|B)[01][01_]*(n)?\b(?!\$) + captures + + 1 + + name + storage.type.numeric.bigint.tsx + + + + + name + constant.numeric.octal.tsx + match + \b(?<!\$)0(?:o|O)?[0-7][0-7_]*(n)?\b(?!\$) + captures + + 1 + + name + storage.type.numeric.bigint.tsx + + + + + match + (?x) +(?<!\$)(?: + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.1E+3 + (?:\b[0-9][0-9_]*(\.)[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1.E+3 + (?:\B(\.)[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # .1E+3 + (?:\b[0-9][0-9_]*[eE][+-]?[0-9][0-9_]*(n)?\b)| # 1E+3 + (?:\b[0-9][0-9_]*(\.)[0-9][0-9_]*(n)?\b)| # 1.1 + (?:\b[0-9][0-9_]*(\.)(n)?\B)| # 1. + (?:\B(\.)[0-9][0-9_]*(n)?\b)| # .1 + (?:\b[0-9][0-9_]*(n)?\b(?!\.)) # 1 +)(?!\$) + captures + + 0 + + name + constant.numeric.decimal.tsx + + 1 + + name + meta.delimiter.decimal.period.tsx + + 2 + + name + storage.type.numeric.bigint.tsx + + 3 + + name + meta.delimiter.decimal.period.tsx + + 4 + + name + storage.type.numeric.bigint.tsx + + 5 + + name + meta.delimiter.decimal.period.tsx + + 6 + + name + storage.type.numeric.bigint.tsx + + 7 + + name + storage.type.numeric.bigint.tsx + + 8 + + name + meta.delimiter.decimal.period.tsx + + 9 + + name + storage.type.numeric.bigint.tsx + + 10 + + name + meta.delimiter.decimal.period.tsx + + 11 + + name + storage.type.numeric.bigint.tsx + + 12 + + name + meta.delimiter.decimal.period.tsx + + 13 + + name + storage.type.numeric.bigint.tsx + + 14 + + name + storage.type.numeric.bigint.tsx + + + + + + boolean-literal + + patterns + + + name + constant.language.boolean.true.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))true(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + constant.language.boolean.false.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))false(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + + null-literal + + name + constant.language.null.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))null(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + this-literal + + name + variable.language.this.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))this\b(?!\$) + + super-literal + + name + variable.language.super.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))super\b(?!\$) + + undefined-literal + + name + constant.language.undefined.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))undefined(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + numericConstant-literal + + patterns + + + name + constant.language.nan.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))NaN(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + constant.language.infinity.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Infinity(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + + support-objects + + patterns + + + name + variable.language.arguments.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(arguments)\b(?!\$) + + + name + support.class.builtin.tsx + match + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Array|ArrayBuffer|Atomics|BigInt|BigInt64Array|BigUint64Array|Boolean|DataView|Date|Float32Array + |Float64Array|Function|Generator|GeneratorFunction|Int8Array|Int16Array|Int32Array|Intl|Map|Number|Object|Proxy + |Reflect|RegExp|Set|SharedArrayBuffer|SIMD|String|Symbol|TypedArray + |Uint8Array|Uint16Array|Uint32Array|Uint8ClampedArray|WeakMap|WeakSet)\b(?!\$) + + + name + support.class.error.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))((Eval|Internal|Range|Reference|Syntax|Type|URI)?Error)\b(?!\$) + + + name + support.class.promise.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Promise)\b(?!\$) + + + name + support.function.tsx + match + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(clear(Interval|Timeout)|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval| + isFinite|isNaN|parseFloat|parseInt|require|set(Interval|Timeout)|super|unescape|uneval)(?=\s*\() + + + match + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Math)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(?: + (abs|acos|acosh|asin|asinh|atan|atan2|atanh|cbrt|ceil|clz32|cos|cosh|exp| + expm1|floor|fround|hypot|imul|log|log10|log1p|log2|max|min|pow|random| + round|sign|sin|sinh|sqrt|tan|tanh|trunc) + | + (E|LN10|LN2|LOG10E|LOG2E|PI|SQRT1_2|SQRT2)))?\b(?!\$) + captures + + 1 + + name + support.constant.math.tsx + + 2 + + name + punctuation.accessor.tsx + + 3 + + name + punctuation.accessor.optional.tsx + + 4 + + name + support.function.math.tsx + + 5 + + name + support.constant.property.math.tsx + + + + + match + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(console)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*( + assert|clear|count|debug|dir|error|group|groupCollapsed|groupEnd|info|log + |profile|profileEnd|table|time|timeEnd|timeStamp|trace|warn))?\b(?!\$) + captures + + 1 + + name + support.class.console.tsx + + 2 + + name + punctuation.accessor.tsx + + 3 + + name + punctuation.accessor.optional.tsx + + 4 + + name + support.function.console.tsx + + + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(JSON)(?:\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(parse|stringify))?\b(?!\$) + captures + + 1 + + name + support.constant.json.tsx + + 2 + + name + punctuation.accessor.tsx + + 3 + + name + punctuation.accessor.optional.tsx + + 4 + + name + support.function.json.tsx + + + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(import)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(meta)\b(?!\$) + captures + + 1 + + name + keyword.control.import.tsx + + 2 + + name + punctuation.accessor.tsx + + 3 + + name + punctuation.accessor.optional.tsx + + 4 + + name + support.variable.property.importmeta.tsx + + + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(new)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(target)\b(?!\$) + captures + + 1 + + name + keyword.operator.new.tsx + + 2 + + name + punctuation.accessor.tsx + + 3 + + name + punctuation.accessor.optional.tsx + + 4 + + name + support.variable.property.target.tsx + + + + + match + (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?: + (?:(constructor|length|prototype|__proto__)\b(?!\$|\s*(<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\()) + | + (?:(EPSILON|MAX_SAFE_INTEGER|MAX_VALUE|MIN_SAFE_INTEGER|MIN_VALUE|NEGATIVE_INFINITY|POSITIVE_INFINITY)\b(?!\$))) + captures + + 1 + + name + punctuation.accessor.tsx + + 2 + + name + punctuation.accessor.optional.tsx + + 3 + + name + support.variable.property.tsx + + 4 + + name + support.constant.tsx + + + + + match + (?x) (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.)) \b (?: + (document|event|navigator|performance|screen|window) + | + (AnalyserNode|ArrayBufferView|Attr|AudioBuffer|AudioBufferSourceNode|AudioContext|AudioDestinationNode|AudioListener + |AudioNode|AudioParam|BatteryManager|BeforeUnloadEvent|BiquadFilterNode|Blob|BufferSource|ByteString|CSS|CSSConditionRule + |CSSCounterStyleRule|CSSGroupingRule|CSSMatrix|CSSMediaRule|CSSPageRule|CSSPrimitiveValue|CSSRule|CSSRuleList|CSSStyleDeclaration + |CSSStyleRule|CSSStyleSheet|CSSSupportsRule|CSSValue|CSSValueList|CanvasGradient|CanvasImageSource|CanvasPattern + |CanvasRenderingContext2D|ChannelMergerNode|ChannelSplitterNode|CharacterData|ChromeWorker|CloseEvent|Comment|CompositionEvent + |Console|ConvolverNode|Coordinates|Credential|CredentialsContainer|Crypto|CryptoKey|CustomEvent|DOMError|DOMException + |DOMHighResTimeStamp|DOMImplementation|DOMString|DOMStringList|DOMStringMap|DOMTimeStamp|DOMTokenList|DataTransfer + |DataTransferItem|DataTransferItemList|DedicatedWorkerGlobalScope|DelayNode|DeviceProximityEvent|DirectoryEntry + |DirectoryEntrySync|DirectoryReader|DirectoryReaderSync|Document|DocumentFragment|DocumentTouch|DocumentType|DragEvent + |DynamicsCompressorNode|Element|Entry|EntrySync|ErrorEvent|Event|EventListener|EventSource|EventTarget|FederatedCredential + |FetchEvent|File|FileEntry|FileEntrySync|FileException|FileList|FileReader|FileReaderSync|FileSystem|FileSystemSync + |FontFace|FormData|GainNode|Gamepad|GamepadButton|GamepadEvent|Geolocation|GlobalEventHandlers|HTMLAnchorElement + |HTMLAreaElement|HTMLAudioElement|HTMLBRElement|HTMLBaseElement|HTMLBodyElement|HTMLButtonElement|HTMLCanvasElement + |HTMLCollection|HTMLContentElement|HTMLDListElement|HTMLDataElement|HTMLDataListElement|HTMLDialogElement|HTMLDivElement + |HTMLDocument|HTMLElement|HTMLEmbedElement|HTMLFieldSetElement|HTMLFontElement|HTMLFormControlsCollection|HTMLFormElement + |HTMLHRElement|HTMLHeadElement|HTMLHeadingElement|HTMLHtmlElement|HTMLIFrameElement|HTMLImageElement|HTMLInputElement + |HTMLKeygenElement|HTMLLIElement|HTMLLabelElement|HTMLLegendElement|HTMLLinkElement|HTMLMapElement|HTMLMediaElement + |HTMLMetaElement|HTMLMeterElement|HTMLModElement|HTMLOListElement|HTMLObjectElement|HTMLOptGroupElement|HTMLOptionElement + |HTMLOptionsCollection|HTMLOutputElement|HTMLParagraphElement|HTMLParamElement|HTMLPreElement|HTMLProgressElement + |HTMLQuoteElement|HTMLScriptElement|HTMLSelectElement|HTMLShadowElement|HTMLSourceElement|HTMLSpanElement|HTMLStyleElement + |HTMLTableCaptionElement|HTMLTableCellElement|HTMLTableColElement|HTMLTableDataCellElement|HTMLTableElement|HTMLTableHeaderCellElement + |HTMLTableRowElement|HTMLTableSectionElement|HTMLTextAreaElement|HTMLTimeElement|HTMLTitleElement|HTMLTrackElement + |HTMLUListElement|HTMLUnknownElement|HTMLVideoElement|HashChangeEvent|History|IDBCursor|IDBCursorWithValue|IDBDatabase + |IDBEnvironment|IDBFactory|IDBIndex|IDBKeyRange|IDBMutableFile|IDBObjectStore|IDBOpenDBRequest|IDBRequest|IDBTransaction + |IDBVersionChangeEvent|IIRFilterNode|IdentityManager|ImageBitmap|ImageBitmapFactories|ImageData|Index|InputDeviceCapabilities + |InputEvent|InstallEvent|InstallTrigger|KeyboardEvent|LinkStyle|LocalFileSystem|LocalFileSystemSync|Location|MIDIAccess + |MIDIConnectionEvent|MIDIInput|MIDIInputMap|MIDIOutputMap|MediaElementAudioSourceNode|MediaError|MediaKeyMessageEvent + |MediaKeySession|MediaKeyStatusMap|MediaKeySystemAccess|MediaKeySystemConfiguration|MediaKeys|MediaRecorder|MediaStream + |MediaStreamAudioDestinationNode|MediaStreamAudioSourceNode|MessageChannel|MessageEvent|MessagePort|MouseEvent + |MutationObserver|MutationRecord|NamedNodeMap|Navigator|NavigatorConcurrentHardware|NavigatorGeolocation|NavigatorID + |NavigatorLanguage|NavigatorOnLine|Node|NodeFilter|NodeIterator|NodeList|NonDocumentTypeChildNode|Notification + |OfflineAudioCompletionEvent|OfflineAudioContext|OscillatorNode|PageTransitionEvent|PannerNode|ParentNode|PasswordCredential + |Path2D|PaymentAddress|PaymentRequest|PaymentResponse|Performance|PerformanceEntry|PerformanceFrameTiming|PerformanceMark + |PerformanceMeasure|PerformanceNavigation|PerformanceNavigationTiming|PerformanceObserver|PerformanceObserverEntryList + |PerformanceResourceTiming|PerformanceTiming|PeriodicSyncEvent|PeriodicWave|Plugin|Point|PointerEvent|PopStateEvent + |PortCollection|Position|PositionError|PositionOptions|PresentationConnectionClosedEvent|PresentationConnectionList + |PresentationReceiver|ProcessingInstruction|ProgressEvent|PromiseRejectionEvent|PushEvent|PushRegistrationManager + |RTCCertificate|RTCConfiguration|RTCPeerConnection|RTCSessionDescriptionCallback|RTCStatsReport|RadioNodeList|RandomSource + |Range|ReadableByteStream|RenderingContext|SVGAElement|SVGAngle|SVGAnimateColorElement|SVGAnimateElement|SVGAnimateMotionElement + |SVGAnimateTransformElement|SVGAnimatedAngle|SVGAnimatedBoolean|SVGAnimatedEnumeration|SVGAnimatedInteger|SVGAnimatedLength + |SVGAnimatedLengthList|SVGAnimatedNumber|SVGAnimatedNumberList|SVGAnimatedPoints|SVGAnimatedPreserveAspectRatio + |SVGAnimatedRect|SVGAnimatedString|SVGAnimatedTransformList|SVGAnimationElement|SVGCircleElement|SVGClipPathElement + |SVGCursorElement|SVGDefsElement|SVGDescElement|SVGElement|SVGEllipseElement|SVGEvent|SVGFilterElement|SVGFontElement + |SVGFontFaceElement|SVGFontFaceFormatElement|SVGFontFaceNameElement|SVGFontFaceSrcElement|SVGFontFaceUriElement + |SVGForeignObjectElement|SVGGElement|SVGGlyphElement|SVGGradientElement|SVGHKernElement|SVGImageElement|SVGLength + |SVGLengthList|SVGLineElement|SVGLinearGradientElement|SVGMPathElement|SVGMaskElement|SVGMatrix|SVGMissingGlyphElement + |SVGNumber|SVGNumberList|SVGPathElement|SVGPatternElement|SVGPoint|SVGPolygonElement|SVGPolylineElement|SVGPreserveAspectRatio + |SVGRadialGradientElement|SVGRect|SVGRectElement|SVGSVGElement|SVGScriptElement|SVGSetElement|SVGStopElement|SVGStringList + |SVGStylable|SVGStyleElement|SVGSwitchElement|SVGSymbolElement|SVGTRefElement|SVGTSpanElement|SVGTests|SVGTextElement + |SVGTextPositioningElement|SVGTitleElement|SVGTransform|SVGTransformList|SVGTransformable|SVGUseElement|SVGVKernElement + |SVGViewElement|ServiceWorker|ServiceWorkerContainer|ServiceWorkerGlobalScope|ServiceWorkerRegistration|ServiceWorkerState + |ShadowRoot|SharedWorker|SharedWorkerGlobalScope|SourceBufferList|StereoPannerNode|Storage|StorageEvent|StyleSheet + |StyleSheetList|SubtleCrypto|SyncEvent|Text|TextMetrics|TimeEvent|TimeRanges|Touch|TouchEvent|TouchList|Transferable + |TreeWalker|UIEvent|USVString|VRDisplayCapabilities|ValidityState|WaveShaperNode|WebGL|WebGLActiveInfo|WebGLBuffer + |WebGLContextEvent|WebGLFramebuffer|WebGLProgram|WebGLRenderbuffer|WebGLRenderingContext|WebGLShader|WebGLShaderPrecisionFormat + |WebGLTexture|WebGLTimerQueryEXT|WebGLTransformFeedback|WebGLUniformLocation|WebGLVertexArrayObject|WebGLVertexArrayObjectOES + |WebSocket|WebSockets|WebVTT|WheelEvent|Window|WindowBase64|WindowEventHandlers|WindowTimers|Worker|WorkerGlobalScope + |WorkerLocation|WorkerNavigator|XMLHttpRequest|XMLHttpRequestEventTarget|XMLSerializer|XPathExpression|XPathResult + |XSLTProcessor))\b(?!\$) + captures + + 1 + + name + support.variable.dom.tsx + + 2 + + name + support.class.dom.tsx + + + + + match + (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* (?: + (ATTRIBUTE_NODE|CDATA_SECTION_NODE|COMMENT_NODE|DOCUMENT_FRAGMENT_NODE|DOCUMENT_NODE|DOCUMENT_TYPE_NODE + |DOMSTRING_SIZE_ERR|ELEMENT_NODE|ENTITY_NODE|ENTITY_REFERENCE_NODE|HIERARCHY_REQUEST_ERR|INDEX_SIZE_ERR + |INUSE_ATTRIBUTE_ERR|INVALID_CHARACTER_ERR|NO_DATA_ALLOWED_ERR|NO_MODIFICATION_ALLOWED_ERR|NOT_FOUND_ERR + |NOT_SUPPORTED_ERR|NOTATION_NODE|PROCESSING_INSTRUCTION_NODE|TEXT_NODE|WRONG_DOCUMENT_ERR) + | + (_content|[xyz]|abbr|above|accept|acceptCharset|accessKey|action|align|[av]Link(?:color)?|all|alt|anchors|appCodeName + |appCore|applets|appMinorVersion|appName|appVersion|archive|areas|arguments|attributes|availHeight|availLeft|availTop + |availWidth|axis|background|backgroundColor|backgroundImage|below|bgColor|body|border|borderBottomWidth|borderColor + |borderLeftWidth|borderRightWidth|borderStyle|borderTopWidth|borderWidth|bottom|bufferDepth|callee|caller|caption + |cellPadding|cells|cellSpacing|ch|characterSet|charset|checked|childNodes|chOff|cite|classes|className|clear + |clientInformation|clip|clipBoardData|closed|code|codeBase|codeType|color|colorDepth|cols|colSpan|compact|complete + |components|content|controllers|cookie|cookieEnabled|cords|cpuClass|crypto|current|data|dateTime|declare|defaultCharset + |defaultChecked|defaultSelected|defaultStatus|defaultValue|defaultView|defer|description|dialogArguments|dialogHeight + |dialogLeft|dialogTop|dialogWidth|dir|directories|disabled|display|docmain|doctype|documentElement|elements|embeds + |enabledPlugin|encoding|enctype|entities|event|expando|external|face|fgColor|filename|firstChild|fontFamily|fontSize + |fontWeight|form|formName|forms|frame|frameBorder|frameElement|frames|hasFocus|hash|headers|height|history|host + |hostname|href|hreflang|hspace|htmlFor|httpEquiv|id|ids|ignoreCase|images|implementation|index|innerHeight|innerWidth + |input|isMap|label|lang|language|lastChild|lastIndex|lastMatch|lastModified|lastParen|layer[sXY]|left|leftContext + |lineHeight|link|linkColor|links|listStyleType|localName|location|locationbar|longDesc|lowsrc|lowSrc|marginBottom + |marginHeight|marginLeft|marginRight|marginTop|marginWidth|maxLength|media|menubar|method|mimeTypes|multiline|multiple + |name|nameProp|namespaces|namespaceURI|next|nextSibling|nodeName|nodeType|nodeValue|noHref|noResize|noShade|notationName + |notations|noWrap|object|offscreenBuffering|onLine|onreadystatechange|opener|opsProfile|options|oscpu|outerHeight + |outerWidth|ownerDocument|paddingBottom|paddingLeft|paddingRight|paddingTop|page[XY]|page[XY]Offset|parent|parentLayer + |parentNode|parentWindow|pathname|personalbar|pixelDepth|pkcs11|platform|plugins|port|prefix|previous|previousDibling + |product|productSub|profile|profileend|prompt|prompter|protocol|publicId|readOnly|readyState|referrer|rel|responseText + |responseXML|rev|right|rightContext|rowIndex|rows|rowSpan|rules|scheme|scope|screen[XY]|screenLeft|screenTop|scripts + |scrollbars|scrolling|sectionRowIndex|security|securityPolicy|selected|selectedIndex|selection|self|shape|siblingAbove + |siblingBelow|size|source|specified|standby|start|status|statusbar|statusText|style|styleSheets|suffixes|summary + |systemId|systemLanguage|tagName|tags|target|tBodies|text|textAlign|textDecoration|textIndent|textTransform|tFoot|tHead + |title|toolbar|top|type|undefined|uniqueID|updateInterval|URL|URLUnencoded|useMap|userAgent|userLanguage|userProfile + |vAlign|value|valueType|vendor|vendorSub|version|visibility|vspace|whiteSpace|width|X[MS]LDocument|zIndex))\b(?!\$|\s*(<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\() + captures + + 1 + + name + punctuation.accessor.tsx + + 2 + + name + punctuation.accessor.optional.tsx + + 3 + + name + support.constant.dom.tsx + + 4 + + name + support.variable.property.dom.tsx + + + + + name + support.class.node.tsx + match + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(Buffer|EventEmitter|Server|Pipe|Socket|REPLServer|ReadStream|WriteStream|Stream + |Inflate|Deflate|InflateRaw|DeflateRaw|GZip|GUnzip|Unzip|Zip)\b(?!\$) + + + match + (?x)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(process)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))(?: + (arch|argv|config|connected|env|execArgv|execPath|exitCode|mainModule|pid|platform|release|stderr|stdin|stdout|title|version|versions) + | + (abort|chdir|cwd|disconnect|exit|[sg]ete?[gu]id|send|[sg]etgroups|initgroups|kill|memoryUsage|nextTick|umask|uptime|hrtime) +))?\b(?!\$) + captures + + 1 + + name + support.variable.object.process.tsx + + 2 + + name + punctuation.accessor.tsx + + 3 + + name + punctuation.accessor.optional.tsx + + 4 + + name + support.variable.property.process.tsx + + 5 + + name + support.function.process.tsx + + + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(exports)|(module)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))(exports|id|filename|loaded|parent|children))?)\b(?!\$) + captures + + 1 + + name + support.type.object.module.tsx + + 2 + + name + support.type.object.module.tsx + + 3 + + name + punctuation.accessor.tsx + + 4 + + name + punctuation.accessor.optional.tsx + + 5 + + name + support.type.object.module.tsx + + + + + name + support.variable.object.node.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(global|GLOBAL|root|__dirname|__filename)\b(?!\$) + + + match + (?x) (?:(\.)|(\?\.(?!\s*[[:digit:]]))) \s* +(?: + (on(?:Rowsinserted|Rowsdelete|Rowenter|Rowexit|Resize|Resizestart|Resizeend|Reset| + Readystatechange|Mouseout|Mouseover|Mousedown|Mouseup|Mousemove| + Before(?:cut|deactivate|unload|update|paste|print|editfocus|activate)| + Blur|Scrolltop|Submit|Select|Selectstart|Selectionchange|Hover|Help| + Change|Contextmenu|Controlselect|Cut|Cellchange|Clock|Close|Deactivate| + Datasetchanged|Datasetcomplete|Dataavailable|Drop|Drag|Dragstart|Dragover| + Dragdrop|Dragenter|Dragend|Dragleave|Dblclick|Unload|Paste|Propertychange|Error| + Errorupdate|Keydown|Keyup|Keypress|Focus|Load|Activate|Afterupdate|Afterprint|Abort) + ) | + (shift|showModelessDialog|showModalDialog|showHelp|scroll|scrollX|scrollByPages| + scrollByLines|scrollY|scrollTo|stop|strike|sizeToContent|sidebar|signText|sort| + sup|sub|substr|substring|splice|split|send|set(?:Milliseconds|Seconds|Minutes|Hours| + Month|Year|FullYear|Date|UTC(?:Milliseconds|Seconds|Minutes|Hours|Month|FullYear|Date)| + Time|Hotkeys|Cursor|ZOptions|Active|Resizable|RequestHeader)|search|slice| + savePreferences|small|home|handleEvent|navigate|char|charCodeAt|charAt|concat| + contextual|confirm|compile|clear|captureEvents|call|createStyleSheet|createPopup| + createEventObject|to(?:GMTString|UTCString|String|Source|UpperCase|LowerCase|LocaleString)| + test|taint|taintEnabled|indexOf|italics|disableExternalCapture|dump|detachEvent|unshift| + untaint|unwatch|updateCommands|join|javaEnabled|pop|push|plugins.refresh|paddings|parse| + print|prompt|preference|enableExternalCapture|exec|execScript|valueOf|UTC|find|file| + fileModifiedDate|fileSize|fileCreatedDate|fileUpdatedDate|fixed|fontsize|fontcolor| + forward|fromCharCode|watch|link|load|lastIndexOf|anchor|attachEvent|atob|apply|alert| + abort|routeEvents|resize|resizeBy|resizeTo|recalc|returnValue|replace|reverse|reload| + releaseCapture|releaseEvents|go|get(?:Milliseconds|Seconds|Minutes|Hours|Month|Day|Year|FullYear| + Time|Date|TimezoneOffset|UTC(?:Milliseconds|Seconds|Minutes|Hours|Day|Month|FullYear|Date)| + Attention|Selection|ResponseHeader|AllResponseHeaders)|moveBy|moveBelow|moveTo| + moveToAbsolute|moveAbove|mergeAttributes|match|margins|btoa|big|bold|borderWidths|blink|back + ) | + (acceptNode|add|addEventListener|addTextTrack|adoptNode|after|animate|append| + appendChild|appendData|before|blur|canPlayType|captureStream| + caretPositionFromPoint|caretRangeFromPoint|checkValidity|clear|click| + cloneContents|cloneNode|cloneRange|close|closest|collapse| + compareBoundaryPoints|compareDocumentPosition|comparePoint|contains| + convertPointFromNode|convertQuadFromNode|convertRectFromNode|createAttribute| + createAttributeNS|createCaption|createCDATASection|createComment| + createContextualFragment|createDocument|createDocumentFragment| + createDocumentType|createElement|createElementNS|createEntityReference| + createEvent|createExpression|createHTMLDocument|createNodeIterator| + createNSResolver|createProcessingInstruction|createRange|createShadowRoot| + createTBody|createTextNode|createTFoot|createTHead|createTreeWalker|delete| + deleteCaption|deleteCell|deleteContents|deleteData|deleteRow|deleteTFoot| + deleteTHead|detach|disconnect|dispatchEvent|elementFromPoint|elementsFromPoint| + enableStyleSheetsForSet|entries|evaluate|execCommand|exitFullscreen| + exitPointerLock|expand|extractContents|fastSeek|firstChild|focus|forEach|get| + getAll|getAnimations|getAttribute|getAttributeNames|getAttributeNode| + getAttributeNodeNS|getAttributeNS|getBoundingClientRect|getBoxQuads| + getClientRects|getContext|getDestinationInsertionPoints|getElementById| + getElementsByClassName|getElementsByName|getElementsByTagName| + getElementsByTagNameNS|getItem|getNamedItem|getSelection|getStartDate| + getVideoPlaybackQuality|has|hasAttribute|hasAttributeNS|hasAttributes| + hasChildNodes|hasFeature|hasFocus|importNode|initEvent|insertAdjacentElement| + insertAdjacentHTML|insertAdjacentText|insertBefore|insertCell|insertData| + insertNode|insertRow|intersectsNode|isDefaultNamespace|isEqualNode| + isPointInRange|isSameNode|item|key|keys|lastChild|load|lookupNamespaceURI| + lookupPrefix|matches|move|moveAttribute|moveAttributeNode|moveChild| + moveNamedItem|namedItem|nextNode|nextSibling|normalize|observe|open| + parentNode|pause|play|postMessage|prepend|preventDefault|previousNode| + previousSibling|probablySupportsContext|queryCommandEnabled| + queryCommandIndeterm|queryCommandState|queryCommandSupported|queryCommandValue| + querySelector|querySelectorAll|registerContentHandler|registerElement| + registerProtocolHandler|releaseCapture|releaseEvents|remove|removeAttribute| + removeAttributeNode|removeAttributeNS|removeChild|removeEventListener| + removeItem|replace|replaceChild|replaceData|replaceWith|reportValidity| + requestFullscreen|requestPointerLock|reset|scroll|scrollBy|scrollIntoView| + scrollTo|seekToNextFrame|select|selectNode|selectNodeContents|set|setAttribute| + setAttributeNode|setAttributeNodeNS|setAttributeNS|setCapture| + setCustomValidity|setEnd|setEndAfter|setEndBefore|setItem|setNamedItem| + setRangeText|setSelectionRange|setSinkId|setStart|setStartAfter|setStartBefore| + slice|splitText|stepDown|stepUp|stopImmediatePropagation|stopPropagation| + submit|substringData|supports|surroundContents|takeRecords|terminate|toBlob| + toDataURL|toggle|toString|values|write|writeln + ) | + (all|catch|finally|race|reject|resolve|then + ) +)(?=\s*\() + captures + + 1 + + name + punctuation.accessor.tsx + + 2 + + name + punctuation.accessor.optional.tsx + + 3 + + name + support.function.event-handler.tsx + + 4 + + name + support.function.tsx + + 5 + + name + support.function.dom.tsx + + 6 + + name + support.function.promise.tsx + + + + + + identifiers + + patterns + + + include + #object-identifiers + + + match + (?x)(?:(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*)?([_$[:alpha:]][_$[:alnum:]]*)(?=\s*=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) +) | +( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends +) | +# arrow function possible to detect only with => on same line +( + (<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*(((const\s+)?[_$[:alpha:]])|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator +) + )) +)) + captures + + 1 + + name + punctuation.accessor.tsx + + 2 + + name + punctuation.accessor.optional.tsx + + 3 + + name + entity.name.function.tsx + + + + + match + (?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(\#?[[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]]) + captures + + 1 + + name + punctuation.accessor.tsx + + 2 + + name + punctuation.accessor.optional.tsx + + 3 + + name + variable.other.constant.property.tsx + + + + + match + (?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(\#?[_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + punctuation.accessor.tsx + + 2 + + name + punctuation.accessor.optional.tsx + + 3 + + name + variable.other.property.tsx + + + + + name + variable.other.constant.tsx + match + ([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]]) + + + name + variable.other.readwrite.tsx + match + [_$[:alpha:]][_$[:alnum:]]* + + + + object-identifiers + + patterns + + + name + support.class.tsx + match + ([_$[:alpha:]][_$[:alnum:]]*)(?=\s*\??\.\s*prototype\b(?!\$)) + + + match + (?x)(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(?: + (\#?[[:upper:]][_$[:digit:][:upper:]]*) | + (\#?[_$[:alpha:]][_$[:alnum:]]*) +)(?=\s*\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + punctuation.accessor.tsx + + 2 + + name + punctuation.accessor.optional.tsx + + 3 + + name + variable.other.constant.object.property.tsx + + 4 + + name + variable.other.object.property.tsx + + + + + match + (?x)(?: + ([[:upper:]][_$[:digit:][:upper:]]*) | + ([_$[:alpha:]][_$[:alnum:]]*) +)(?=\s*\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*) + captures + + 1 + + name + variable.other.constant.object.tsx + + 2 + + name + variable.other.object.tsx + + + + + + type-annotation + + patterns + + + name + meta.type.annotation.tsx + begin + (:)(?=\s*\S) + beginCaptures + + 1 + + name + keyword.operator.type.annotation.tsx + + + end + (?<![:|&])(?!\s*[|&]\s+)((?=^|[,);\}\]]|//)|(?==[^>])|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{))) + patterns + + + include + #type + + + + + name + meta.type.annotation.tsx + begin + (:) + beginCaptures + + 1 + + name + keyword.operator.type.annotation.tsx + + + end + (?<![:|&])((?=[,);\}\]]|\/\/)|(?==[^>])|(?=^\s*$)|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{))) + patterns + + + include + #type + + + + + + parameter-type-annotation + + patterns + + + name + meta.type.annotation.tsx + begin + (:) + beginCaptures + + 1 + + name + keyword.operator.type.annotation.tsx + + + end + (?=[,)])|(?==[^>]) + patterns + + + include + #type + + + + + + return-type + + patterns + + + name + meta.return.type.tsx + begin + (?<=\))\s*(:)(?=\s*\S) + beginCaptures + + 1 + + name + keyword.operator.type.annotation.tsx + + + end + (?<![:|&])(?=$|^|[{};,]|//) + patterns + + + include + #return-type-core + + + + + name + meta.return.type.tsx + begin + (?<=\))\s*(:) + beginCaptures + + 1 + + name + keyword.operator.type.annotation.tsx + + + end + (?<![:|&])((?=[{};,]|//|^\s*$)|((?<=\S)(?=\s*$))) + patterns + + + include + #return-type-core + + + + + + return-type-core + + patterns + + + include + #comment + + + begin + (?<=[:|&])(?=\s*\{) + end + (?<=\}) + patterns + + + include + #type-object + + + + + include + #type-predicate-operator + + + include + #type + + + + arrow-return-type + + name + meta.return.type.arrow.tsx + begin + (?<=\))\s*(:) + beginCaptures + + 1 + + name + keyword.operator.type.annotation.tsx + + + end + (?==>|\{|(^\s*(export|function|class|interface|let|var|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|const|import|enum|namespace|module|type|abstract|declare)\s+)) + patterns + + + include + #arrow-return-type-body + + + + possibly-arrow-return-type + + begin + (?<=\)|^)\s*(:)(?=\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*=>) + beginCaptures + + 1 + + name + meta.arrow.tsx meta.return.type.arrow.tsx keyword.operator.type.annotation.tsx + + + end + (?==>|\{|(^\s*(export|function|class|interface|let|var|(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)|(?:\bawait\s+(?:\busing(?=\s+(?!in\b|of\b(?!\s*(?:of\b|=)))[_$[:alpha:]])\b)\b)|const|import|enum|namespace|module|type|abstract|declare)\s+)) + contentName + meta.arrow.tsx meta.return.type.arrow.tsx + patterns + + + include + #arrow-return-type-body + + + + arrow-return-type-body + + patterns + + + begin + (?<=[:])(?=\s*\{) + end + (?<=\}) + patterns + + + include + #type-object + + + + + include + #type-predicate-operator + + + include + #type + + + + type-parameters + + name + meta.type.parameters.tsx + begin + (<) + beginCaptures + + 1 + + name + punctuation.definition.typeparameters.begin.tsx + + + end + (>) + endCaptures + + 1 + + name + punctuation.definition.typeparameters.end.tsx + + + patterns + + + include + #comment + + + name + storage.modifier.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(extends|in|out|const)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + include + #type + + + include + #punctuation-comma + + + name + keyword.operator.assignment.tsx + match + (=)(?!>) + + + + type-arguments + + name + meta.type.parameters.tsx + begin + \< + beginCaptures + + 0 + + name + punctuation.definition.typeparameters.begin.tsx + + + end + \> + endCaptures + + 0 + + name + punctuation.definition.typeparameters.end.tsx + + + patterns + + + include + #type-arguments-body + + + + type-arguments-body + + patterns + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(_)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + captures + + 0 + + name + keyword.operator.type.tsx + + + + + include + #type + + + include + #punctuation-comma + + + + type + + patterns + + + include + #comment + + + include + #type-string + + + include + #numeric-literal + + + include + #type-primitive + + + include + #type-builtin-literals + + + include + #type-parameters + + + include + #type-tuple + + + include + #type-object + + + include + #type-operators + + + include + #type-conditional + + + include + #type-fn-type-parameters + + + include + #type-paren-or-function-parameters + + + include + #type-function-return-type + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(readonly)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))\s* + captures + + 1 + + name + storage.modifier.tsx + + + + + include + #type-name + + + + type-primitive + + name + support.type.primitive.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(string|number|bigint|boolean|symbol|any|void|never|unknown)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + type-builtin-literals + + name + support.type.builtin.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(this|true|false|undefined|null|object)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + type-tuple + + name + meta.type.tuple.tsx + begin + \[ + beginCaptures + + 0 + + name + meta.brace.square.tsx + + + end + \] + endCaptures + + 0 + + name + meta.brace.square.tsx + + + patterns + + + name + keyword.operator.rest.tsx + match + \.\.\. + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))([_$[:alpha:]][_$[:alnum:]]*)\s*(\?)?\s*(:) + captures + + 1 + + name + entity.name.label.tsx + + 2 + + name + keyword.operator.optional.tsx + + 3 + + name + punctuation.separator.label.tsx + + + + + include + #type + + + include + #punctuation-comma + + + + type-object + + name + meta.object.type.tsx + begin + \{ + beginCaptures + + 0 + + name + punctuation.definition.block.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.block.tsx + + + patterns + + + include + #comment + + + include + #method-declaration + + + include + #indexer-declaration + + + include + #indexer-mapped-type-declaration + + + include + #field-declaration + + + include + #type-annotation + + + begin + \.\.\. + beginCaptures + + 0 + + name + keyword.operator.spread.tsx + + + end + (?=\}|;|,|$)|(?<=\}) + patterns + + + include + #type + + + + + include + #punctuation-comma + + + include + #punctuation-semicolon + + + include + #type + + + + type-conditional + + patterns + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(extends)\s+ + beginCaptures + + 1 + + name + storage.modifier.tsx + + + end + (?<=:) + patterns + + + begin + \? + beginCaptures + + 0 + + name + keyword.operator.ternary.tsx + + + end + : + endCaptures + + 0 + + name + keyword.operator.ternary.tsx + + + patterns + + + include + #type + + + + + include + #type + + + + + + type-paren-or-function-parameters + + name + meta.type.paren.cover.tsx + begin + \( + beginCaptures + + 0 + + name + meta.brace.round.tsx + + + end + \) + endCaptures + + 0 + + name + meta.brace.round.tsx + + + patterns + + + match + (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))\s*(\??)(?=\s*(:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) +)) | +(:\s*(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))Function(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))) | +(:\s*((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))))) + captures + + 1 + + name + storage.modifier.tsx + + 2 + + name + keyword.operator.rest.tsx + + 3 + + name + entity.name.function.tsx variable.language.this.tsx + + 4 + + name + entity.name.function.tsx + + 5 + + name + keyword.operator.optional.tsx + + + + + match + (?x)(?:(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(public|private|protected|readonly)\s+)?(?:(\.\.\.)\s*)?(?<!=|:)(?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))\s*(\??)(?=:) + captures + + 1 + + name + storage.modifier.tsx + + 2 + + name + keyword.operator.rest.tsx + + 3 + + name + variable.parameter.tsx variable.language.this.tsx + + 4 + + name + variable.parameter.tsx + + 5 + + name + keyword.operator.optional.tsx + + + + + include + #type-annotation + + + name + punctuation.separator.parameter.tsx + match + , + + + include + #type + + + + type-fn-type-parameters + + patterns + + + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(new)\b(?=\s*\<) + beginCaptures + + 1 + + name + meta.type.constructor.tsx storage.modifier.tsx + + 2 + + name + meta.type.constructor.tsx keyword.control.new.tsx + + + end + (?<=>) + patterns + + + include + #comment + + + include + #type-parameters + + + + + name + meta.type.constructor.tsx + begin + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(abstract)\s+)?(new)\b\s*(?=\() + beginCaptures + + 1 + + name + storage.modifier.tsx + + 2 + + name + keyword.control.new.tsx + + + end + (?<=\)) + patterns + + + include + #function-parameters + + + + + name + meta.type.function.tsx + begin + (?x)( + (?= + [(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + ) + ) +) + end + (?<=\)) + patterns + + + include + #function-parameters + + + + + + type-function-return-type + + patterns + + + name + meta.type.function.return.tsx + begin + (=>)(?=\s*\S) + beginCaptures + + 1 + + name + storage.type.function.arrow.tsx + + + end + (?<!=>)(?<![|&])(?=[,\]\)\{\}=;>:\?]|//|$) + patterns + + + include + #type-function-return-type-core + + + + + name + meta.type.function.return.tsx + begin + => + beginCaptures + + 0 + + name + storage.type.function.arrow.tsx + + + end + (?<!=>)(?<![|&])((?=[,\]\)\{\}=;:\?>]|//|^\s*$)|((?<=\S)(?=\s*$))) + patterns + + + include + #type-function-return-type-core + + + + + + type-function-return-type-core + + patterns + + + include + #comment + + + begin + (?<==>)(?=\s*\{) + end + (?<=\}) + patterns + + + include + #type-object + + + + + include + #type-predicate-operator + + + include + #type + + + + type-operators + + patterns + + + include + #typeof-operator + + + include + #type-infer + + + begin + ([&|])(?=\s*\{) + beginCaptures + + 0 + + name + keyword.operator.type.tsx + + + end + (?<=\}) + patterns + + + include + #type-object + + + + + begin + [&|] + beginCaptures + + 0 + + name + keyword.operator.type.tsx + + + end + (?=\S) + + + name + keyword.operator.expression.keyof.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))keyof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.operator.ternary.tsx + match + (\?|\:) + + + name + keyword.operator.expression.import.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))import(?=\s*\() + + + + type-infer + + patterns + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(infer)\s+([_$[:alpha:]][_$[:alnum:]]*)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.))(?:\s+(extends)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))? + name + meta.type.infer.tsx + captures + + 1 + + name + keyword.operator.expression.infer.tsx + + 2 + + name + entity.name.type.tsx + + 3 + + name + keyword.operator.expression.extends.tsx + + + + + + type-predicate-operator + + patterns + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(?:(asserts)\s+)?(?!asserts)(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))\s(is)(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + captures + + 1 + + name + keyword.operator.type.asserts.tsx + + 2 + + name + variable.parameter.tsx variable.language.this.tsx + + 3 + + name + variable.parameter.tsx + + 4 + + name + keyword.operator.expression.is.tsx + + + + + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))(asserts)\s+(?!is)(?:(this)|([_$[:alpha:]][_$[:alnum:]]*))(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + captures + + 1 + + name + keyword.operator.type.asserts.tsx + + 2 + + name + variable.parameter.tsx variable.language.this.tsx + + 3 + + name + variable.parameter.tsx + + + + + name + keyword.operator.type.asserts.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))asserts(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + name + keyword.operator.expression.is.tsx + match + (?<![_$[:alnum:]])(?:(?<=\.\.\.)|(?<!\.))is(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)) + + + + type-name + + patterns + + + begin + ([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(<) + captures + + 1 + + name + entity.name.type.module.tsx + + 2 + + name + punctuation.accessor.tsx + + 3 + + name + punctuation.accessor.optional.tsx + + 4 + + name + meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + + + end + (>) + endCaptures + + 1 + + name + meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + + + contentName + meta.type.parameters.tsx + patterns + + + include + #type-arguments-body + + + + + begin + ([_$[:alpha:]][_$[:alnum:]]*)\s*(<) + beginCaptures + + 1 + + name + entity.name.type.tsx + + 2 + + name + meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + + + end + (>) + endCaptures + + 1 + + name + meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + + + contentName + meta.type.parameters.tsx + patterns + + + include + #type-arguments-body + + + + + match + ([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]]))) + captures + + 1 + + name + entity.name.type.module.tsx + + 2 + + name + punctuation.accessor.tsx + + 3 + + name + punctuation.accessor.optional.tsx + + + + + name + entity.name.type.tsx + match + [_$[:alpha:]][_$[:alnum:]]* + + + + punctuation-comma + + name + punctuation.separator.comma.tsx + match + , + + punctuation-semicolon + + name + punctuation.terminator.statement.tsx + match + ; + + punctuation-accessor + + match + (?:(\.)|(\?\.(?!\s*[[:digit:]]))) + captures + + 1 + + name + punctuation.accessor.tsx + + 2 + + name + punctuation.accessor.optional.tsx + + + + string + + patterns + + + include + #qstring-single + + + include + #qstring-double + + + include + #template + + + + qstring-double + + name + string.quoted.double.tsx + begin + " + beginCaptures + + 0 + + name + punctuation.definition.string.begin.tsx + + + end + (")|((?:[^\\\n])$) + endCaptures + + 1 + + name + punctuation.definition.string.end.tsx + + 2 + + name + invalid.illegal.newline.tsx + + + patterns + + + include + #string-character-escape + + + + qstring-single + + name + string.quoted.single.tsx + begin + ' + beginCaptures + + 0 + + name + punctuation.definition.string.begin.tsx + + + end + (\')|((?:[^\\\n])$) + endCaptures + + 1 + + name + punctuation.definition.string.end.tsx + + 2 + + name + invalid.illegal.newline.tsx + + + patterns + + + include + #string-character-escape + + + + string-character-escape + + name + constant.character.escape.tsx + match + \\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\{[0-9A-Fa-f]+\}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$) + + template + + patterns + + + include + #template-call + + + contentName + string.template.tsx + begin + ([_$[:alpha:]][_$[:alnum:]]*)?(`) + beginCaptures + + 1 + + name + entity.name.function.tagged-template.tsx + + 2 + + name + string.template.tsx punctuation.definition.string.template.begin.tsx + + + end + ` + endCaptures + + 0 + + name + string.template.tsx punctuation.definition.string.template.end.tsx + + + patterns + + + include + #template-substitution-element + + + include + #string-character-escape + + + + + + template-call + + patterns + + + begin + (?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?`) + end + (?=`) + patterns + + + begin + (?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*)) + end + (?=(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)?`) + patterns + + + include + #support-function-call-identifiers + + + name + entity.name.function.tagged-template.tsx + match + ([_$[:alpha:]][_$[:alnum:]]*) + + + + + include + #type-arguments + + + + + begin + ([_$[:alpha:]][_$[:alnum:]]*)?\s*(?=(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?<!=)\>))*(?<!=)\>)*(?<!=)>\s*)`) + beginCaptures + + 1 + + name + entity.name.function.tagged-template.tsx + + + end + (?=`) + patterns + + + include + #type-arguments + + + + + + template-substitution-element + + name + meta.template.expression.tsx + begin + \$\{ + beginCaptures + + 0 + + name + punctuation.definition.template-expression.begin.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.template-expression.end.tsx + + + patterns + + + include + #expression + + + contentName + meta.embedded.line.tsx + + type-string + + patterns + + + include + #qstring-single + + + include + #qstring-double + + + include + #template-type + + + + template-type + + patterns + + + include + #template-call + + + contentName + string.template.tsx + begin + ([_$[:alpha:]][_$[:alnum:]]*)?(`) + beginCaptures + + 1 + + name + entity.name.function.tagged-template.tsx + + 2 + + name + string.template.tsx punctuation.definition.string.template.begin.tsx + + + end + ` + endCaptures + + 0 + + name + string.template.tsx punctuation.definition.string.template.end.tsx + + + patterns + + + include + #template-type-substitution-element + + + include + #string-character-escape + + + + + + template-type-substitution-element + + name + meta.template.expression.tsx + begin + \$\{ + beginCaptures + + 0 + + name + punctuation.definition.template-expression.begin.tsx + + + end + \} + endCaptures + + 0 + + name + punctuation.definition.template-expression.end.tsx + + + patterns + + + include + #type + + + contentName + meta.embedded.line.tsx + + regex + + patterns + + + name + string.regexp.tsx + begin + (?<!\+\+|--|})(?<=[=(:,\[?+!]|^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case|=>|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[\()]|\\.|\[([^\]\\]|\\.)+\]|\(([^\)\\]|\\.)+\))+\/([dgimsuvy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$])) + beginCaptures + + 1 + + name + punctuation.definition.string.begin.tsx + + + end + (/)([dgimsuvy]*) + endCaptures + + 1 + + name + punctuation.definition.string.end.tsx + + 2 + + name + keyword.other.tsx + + + patterns + + + include + #regexp + + + + + name + string.regexp.tsx + begin + ((?<![_$[:alnum:])\]]|\+\+|--|}|\*\/)|((?<=^return|[^\._$[:alnum:]]return|^case|[^\._$[:alnum:]]case))\s*)\/(?![\/*])(?=(?:[^\/\\\[]|\\.|\[([^\]\\]|\\.)*\])+\/([dgimsuvy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$])) + beginCaptures + + 0 + + name + punctuation.definition.string.begin.tsx + + + end + (/)([dgimsuvy]*) + endCaptures + + 1 + + name + punctuation.definition.string.end.tsx + + 2 + + name + keyword.other.tsx + + + patterns + + + include + #regexp + + + + + + regexp + + patterns + + + name + keyword.control.anchor.regexp + match + \\[bB]|\^|\$ + + + match + \\[1-9]\d*|\\k<([a-zA-Z_$][\w$]*)> + captures + + 0 + + name + keyword.other.back-reference.regexp + + 1 + + name + variable.other.regexp + + + + + name + keyword.operator.quantifier.regexp + match + [?+*]|\{(\d+,\d+|\d+,|,\d+|\d+)\}\?? + + + name + keyword.operator.or.regexp + match + \| + + + name + meta.group.assertion.regexp + begin + (\()((\?=)|(\?!)|(\?<=)|(\?<!)) + beginCaptures + + 1 + + name + punctuation.definition.group.regexp + + 2 + + name + punctuation.definition.group.assertion.regexp + + 3 + + name + meta.assertion.look-ahead.regexp + + 4 + + name + meta.assertion.negative-look-ahead.regexp + + 5 + + name + meta.assertion.look-behind.regexp + + 6 + + name + meta.assertion.negative-look-behind.regexp + + + end + (\)) + endCaptures + + 1 + + name + punctuation.definition.group.regexp + + + patterns + + + include + #regexp + + + + + name + meta.group.regexp + begin + \((?:(\?:)|(?:\?<([a-zA-Z_$][\w$]*)>))? + beginCaptures + + 0 + + name + punctuation.definition.group.regexp + + 1 + + name + punctuation.definition.group.no-capture.regexp + + 2 + + name + variable.other.regexp + + + end + \) + endCaptures + + 0 + + name + punctuation.definition.group.regexp + + + patterns + + + include + #regexp + + + + + name + constant.other.character-class.set.regexp + begin + (\[)(\^)? + beginCaptures + + 1 + + name + punctuation.definition.character-class.regexp + + 2 + + name + keyword.operator.negation.regexp + + + end + (\]) + endCaptures + + 1 + + name + punctuation.definition.character-class.regexp + + + patterns + + + name + constant.other.character-class.range.regexp + match + (?:.|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.))\-(?:[^\]\\]|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.)) + captures + + 1 + + name + constant.character.numeric.regexp + + 2 + + name + constant.character.control.regexp + + 3 + + name + constant.character.escape.backslash.regexp + + 4 + + name + constant.character.numeric.regexp + + 5 + + name + constant.character.control.regexp + + 6 + + name + constant.character.escape.backslash.regexp + + + + + include + #regex-character-class + + + + + include + #regex-character-class + + + + regex-character-class + + patterns + + + name + constant.other.character-class.regexp + match + \\[wWsSdDtrnvf]|\. + + + name + constant.character.numeric.regexp + match + \\([0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}) + + + name + constant.character.control.regexp + match + \\c[A-Z] + + + name + constant.character.escape.backslash.regexp + match + \\. + + + + comment + + patterns + + + name + comment.block.documentation.tsx + begin + /\*\*(?!/) + beginCaptures + + 0 + + name + punctuation.definition.comment.tsx + + + end + \*/ + endCaptures + + 0 + + name + punctuation.definition.comment.tsx + + + patterns + + + include + #docblock + + + + + name + comment.block.tsx + begin + (/\*)(?:\s*((@)internal)(?=\s|(\*/)))? + beginCaptures + + 1 + + name + punctuation.definition.comment.tsx + + 2 + + name + storage.type.internaldeclaration.tsx + + 3 + + name + punctuation.decorator.internaldeclaration.tsx + + + end + \*/ + endCaptures + + 0 + + name + punctuation.definition.comment.tsx + + + + + begin + (^[ \t]+)?((//)(?:\s*((@)internal)(?=\s|$))?) + beginCaptures + + 1 + + name + punctuation.whitespace.comment.leading.tsx + + 2 + + name + comment.line.double-slash.tsx + + 3 + + name + punctuation.definition.comment.tsx + + 4 + + name + storage.type.internaldeclaration.tsx + + 5 + + name + punctuation.decorator.internaldeclaration.tsx + + + end + (?=$) + contentName + comment.line.double-slash.tsx + + + + single-line-comment-consuming-line-ending + + begin + (^[ \t]+)?((//)(?:\s*((@)internal)(?=\s|$))?) + beginCaptures + + 1 + + name + punctuation.whitespace.comment.leading.tsx + + 2 + + name + comment.line.double-slash.tsx + + 3 + + name + punctuation.definition.comment.tsx + + 4 + + name + storage.type.internaldeclaration.tsx + + 5 + + name + punctuation.decorator.internaldeclaration.tsx + + + end + (?=^) + contentName + comment.line.double-slash.tsx + + directives + + name + comment.line.triple-slash.directive.tsx + begin + ^(///)\s*(?=<(reference|amd-dependency|amd-module)(\s+(path|types|no-default-lib|lib|name|resolution-mode)\s*=\s*((\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`)))+\s*/>\s*$) + beginCaptures + + 1 + + name + punctuation.definition.comment.tsx + + + end + (?=$) + patterns + + + name + meta.tag.tsx + begin + (<)(reference|amd-dependency|amd-module) + beginCaptures + + 1 + + name + punctuation.definition.tag.directive.tsx + + 2 + + name + entity.name.tag.directive.tsx + + + end + /> + endCaptures + + 0 + + name + punctuation.definition.tag.directive.tsx + + + patterns + + + name + entity.other.attribute-name.directive.tsx + match + path|types|no-default-lib|lib|name|resolution-mode + + + name + keyword.operator.assignment.tsx + match + = + + + include + #string + + + + + + docblock + + patterns + + + match + (?x) +((@)(?:access|api)) +\s+ +(private|protected|public) +\b + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + constant.language.access-type.jsdoc + + + + + match + (?x) +((@)author) +\s+ +( + [^@\s<>*/] + (?:[^@<>*/]|\*[^/])* +) +(?: \s* - ([_$a-zA-Z][-$\w]*) - (?=\s|=|/?>|/\*|//) - name - meta.tag.attribute-name.tsx - - jsx-tag-attributes - - patterns - - - include - #jsx-tag-attribute-name - - - include - #jsx-tag-attribute-assignment - - - include - #jsx-string-double-quoted - - - include - #jsx-string-single-quoted - - - include - #jsx-evaluated-code - - - - jsx-tag-attributes-illegal - - match - \S+ - name - invalid.illegal.attribute.tsx - - jsx-tag-close - - begin - (</)([_$a-zA-Z][-$\w.]*(?<!\.|-)) - beginCaptures - - 1 - - name - punctuation.definition.tag.begin.tsx - - 2 - - name - entity.name.tag.tsx - - - end - (>) - endCaptures - - 1 - - name - punctuation.definition.tag.end.tsx - - - name - tag.close.tsx - patterns - - - include - #comment - - - - jsx-tag-invalid - - match - <\s*> - name - invalid.illegal.tag.incomplete.tsx - - jsx-tag-open - - begin - (?x) (<) - ([_$a-zA-Z][-$\w.]*(?<!\.|-)) - (?=\s+(?!\?)|/?>) - beginCaptures - - 1 - - name - punctuation.definition.tag.begin.tsx - - 2 - - name - entity.name.tag.tsx - - - end - (/?>) - endCaptures - - 1 - - name - punctuation.definition.tag.end.tsx - - - name - tag.open.tsx - patterns - - - include - #comment - - - include - #jsx-tag-attributes - - - include - #jsx-tag-attributes-illegal - - - - jsx-tag-without-attributes - - begin - (<)([_$a-zA-Z][-$\w.]*(?<!\.|-))(>) - beginCaptures - - 1 - - name - punctuation.definition.tag.begin.tsx - - 2 - - name - entity.name.tag.tsx - - 3 - - name - punctuation.definition.tag.end.tsx - - - end - (</)([_$a-zA-Z][-$\w.]*(?<!\.|-))(>) - endCaptures - - 1 - - name - punctuation.definition.tag.begin.tsx - - 2 - - name - entity.name.tag.tsx - - 3 - - name - punctuation.definition.tag.end.tsx - - - name - tag.without-attributes.tsx - patterns - - - include - #jsx-children - - - - literal - - name - literal.tsx - patterns - - - include - #numeric-literal - - - include - #boolean-literal - - - include - #null-literal - - - include - #undefined-literal - - - include - #array-literal - - - include - #this-literal - - - - logic-operator - - match - \!|&&|&|~|\^|\|\||\| - name - keyword.operator.arithmetic.tsx - - method-declaration - - begin - \b(?:(abstract)\s+)?\b(?:(public|private|protected)\s+)?\b(?:(async)\s+)?(?:(get|set)\s+)?(?:(new)|(?:\b(constructor)\b)|(?:([a-zA-Z_$][\.\w$]*)\s*(\??)))?\s*(?=\(|\<) - beginCaptures - - 1 - - name - storage.modifier.tsx - - 2 - - name - storage.modifier.tsx - - 3 - - name - storage.modifier.tsx - - 4 - - name - storage.type.property.tsx - - 5 - - name - keyword.operator.tsx - - 6 - - name - storage.type.tsx - - 7 - - name - entity.name.function.tsx - - 8 - - name - keyword.operator.tsx - - - end - (?=\}|;|,)|(?<=\}) - name - meta.method.declaration.tsx - patterns - - - include - #comment - - - include - #type-parameters - - - include - #function-type-parameters - - - include - #type-annotation - - - include - #method-overload-declaration - - - include - #decl-block - - - - method-overload-declaration - - captures - - 1 - - name - storage.modifier.tsx - - 2 - - name - storage.modifier.tsx - - 3 - - name - storage.modifier.tsx - - 4 - - name - storage.type.property.tsx - - 5 - - name - keyword.operator.tsx - - 6 - - name - storage.type.tsx - - 7 - - name - entity.name.function.tsx - - 8 - - name - keyword.operator.tsx - - - match - \b(?:(abstract)\s+)?\b(?:(public|private|protected)\s+)?\b(?:(async)\s+)?(?:(get|set)\s+)?(?:(new)|(?:\b(constructor)\b)|(?:([a-zA-Z_$][\.\w$]*)\s*(\??)))?\s*(?=\(|\<) - name - meta.method.overload.declaration.tsx - - new-expr - - begin - \b(new)\b - beginCaptures - - 1 - - name - keyword.others.tsx - - - end - (?=[(;]|$) - name - new.expr.tsx - patterns - - - include - #type - - - include - #comment - - - - null-literal - - match - \b(null)\b - name - constant.language.null.tsx - - numeric-literal - - match - \b(?<=[^$])((0(x|X)[0-9a-fA-F]+)|(0(o|O)[0-7]+)|(0(b|B)(0|1)+)|(([0-9]+(\.[0-9]+)?))([eE]([+-]?)[0-9]+(\.[0-9]+)?)?)\b - name - constant.numeric.tsx - - object-body - - begin - \{ - beginCaptures - - 0 - - name - meta.brace.curly.tsx - - - end - \} - endCaptures - - 0 - - name - meta.brace.curly.tsx - - - name - meta.object.body.tsx - patterns - - - include - #string - - - include - #comment - - - include - #field-declaration - - - include - #method-declaration - - - include - #indexer-declaration - - - include - #type-annotation - - - include - #variable-initializer - - - include - #access-modifier - - - include - #static-modifier - - - include - #property-accessor - - - - object-declaration - - begin - \b(?:(export)\s+)?\b(?:(abstract)\s+)?\b(?<!\.)(class|interface)\b - beginCaptures - - 1 - - name - storage.type.tsx - - 2 - - name - storage.modifier.tsx - - 3 - - name - storage.type.tsx - - - end - (?<=\}) - endCaptures - - 1 - - name - brace.curly.tsx - - - name - meta.declaration.object.tsx - patterns - - - include - #comment - - - include - #object-heritage - - - include - #object-name - - - include - #type-parameters - - - include - #object-body - - - - object-heritage - - begin - (?:\b(extends|implements)\b) - beginCaptures - - 1 - - name - keyword.other.tsx - - - end - (?=\{) - endCaptures - - 1 - - name - brace.curly.tsx - - - name - meta.object.heritage.tsx - patterns - - - include - #comment - - - include - #object-heritage - - - include - #type-parameters - - - include - #object-heritage-type - - - - object-heritage-type - - captures - - 1 - - name - support.type.tsx - - - match - (?:\b([a-zA-Z_$][\w$]*)\b) - name - meta.object.heritage.parent.tsx - - object-member - - begin - [a-zA-Z_$][\w$]*\s*: - end - (?=,|\}) - name - meta.object.member.tsx - patterns - - - include - #expression - - - - object-name - - captures - - 0 - - name - entity.name.class.tsx - - - match - [a-zA-Z_$][\w$]* - name - meta.object.name.tsx - - parameter-name - - captures - - 1 - - name - storage.modifier.tsx - - 2 - - name - keyword.others.tsx - - 3 - - name - variable.parameter.tsx - - 4 - - name - keyword.others.tsx - - - match - (?:\s*\b(public|private|protected)\b\s+)?(\.\.\.)?\s*([a-zA-Z_$][\w$]*)\s*(\??) - name - parameter.name.tsx - - paren-expression - - begin - \( - beginCaptures - - 0 - - name - meta.brace.paren.tsx - - - end - \) - endCaptures - - 0 - - name - meta.brace.paren.tsx - - - patterns - - - include - #expression - - - - property-accessor - - match - \b(get|set)\b - name - storage.type.property.tsx - - qstring-double - - begin - " - end - "|(?:[^\\\n]$) - name - string.double.tsx - patterns - - - include - #string-character-escape - - - - qstring-single - - begin - ' - end - \'|(?:[^\\\n]$) - name - string.single.tsx - patterns - - - include - #string-character-escape - - - - regex - - begin - (?<=[=(:,\[]|^|return|&&|\|\||!)\s*(/)(?![/*+{}?]) - end - $|(/)[igm]* - name - string.regex.tsx - patterns - - - match - \\. - name - constant.character.escape.tsx - - - match - \[(\\\]|[^\]])*\] - name - constant.character.class.tsx - - - - relational-operator - - match - ===|!==|==|!=|<=|>=|<>|=|<|> - name - keyword.operator.comparison.tsx - - return-type - - begin - (?<=\))\s*: - end - (?=$)|(?=\{|;|//) - name - meta.return.type.tsx - patterns - - - include - #type - - - - static-modifier - - match - \b(static)\b - name - keyword.other.tsx - - storage-keyword - - match - \b(var|let|function|const|module|namespace|void|export)\b - name - storage.type.tsx - - string - - name - string.tsx - patterns - - - include - #qstring-single - - - include - #qstring-double - - - - string-character-escape - - match - \\(x\h{2}|[0-2][0-7]{,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$) - name - constant.character.escape - - switch-block - - begin - { - end - (?=\}) - name - switch-block.expr.tsx - patterns - - - include - #expression - - - - switch-expression - - begin - \b(switch)\b\s*\( - beginCaptures - - 1 - - name - keyword.control.tsx - - - end - \) - name - switch-expression.expr.tsx - patterns - - - include - #expression - - - - switch-statement - - begin - (?=\bswitch\b\s*\() - end - } - name - switch-statement.expr.tsx - patterns - - - include - #switch-expression - - - include - #switch-block - - - - template - - begin - ` - beginCaptures - - 0 - - name - string.template.tsx - - - end - ` - endCaptures - - 0 - - name - string.template.tsx - - - name - meta.template.tsx - patterns - - - include - #template-substitution-element - - - include - #template-string-contents - - - - template-string-contents - - begin - .*? - end - (?=(\$\{|`)) - name - string.template.tsx - patterns - - - include - #string-character-escape - - - - template-substitution-element - - begin - \$\{ - beginCaptures - - 0 - - name - keyword.others.tsx - - - end - \} - endCaptures - - 0 - - name - keyword.others.tsx - - - name - template.element.tsx - patterns - - - include - #expression - - - - ternary-expression - - begin - (?=\?) - end - (?=$|[;,]) - patterns - - - include - #ternary-operator - - - include - #expression-type - - - - ternary-operator - - begin - (\?) - end - (:) - patterns - - - include - #expression-type - - - - this-literal - - match - \b(this)\b - name - constant.language.this.tsx - - type - - name - meta.type.tsx - patterns - - - include - #type-primitive - - - include - #type-parameters - - - include - #type-tuple - - - include - #type-object - - - include - #type-operator - - - include - #type-paren-or-function-type-parameters - - - include - #type-function-return-type - - - include - #type-name - - - - type-annotation - - begin - : - end - (?=$|[,);\}\]]|//)|(?==[^>])|(?<=[\}>\]\)]|[a-zA-Z_$])\s*(?=\{) - name - meta.type.annotation.tsx - patterns - - - include - #expression-operator - - - include - #type - - - include - #string - - - include - #comment - - - - type-declaration - - begin - \b(type)\b\s+([a-zA-Z_$][\w$]*)\s* - beginCaptures - - 1 - - name - keyword.other.tsx - - 2 - - name - entity.name.class.tsx - - - end - (?=$|[,);>]|var|type|function|class|interface) - name - meta.type.declaration.tsx - patterns - - - include - #type-parameters - - - include - #type - - - match - =\s* - name - keyword.operator.comparison.tsx - - - - type-function-return-type - - begin - => - beginCaptures - - 0 - - name - keyword.operator.tsx - - - end - (?=\s*[,\)\{=;>]|//|$) - name - meta.type.function.return.tsx - patterns - - - include - #type - - - - type-name - - captures - - 1 - - name - entity.name.type.tsx - - - match - [a-zA-Z_$][.\w$]* - name - meta.type.name.tsx - - type-object - - begin - \{ - beginCaptures - - 0 - - name - meta.brace.curly.tsx - - - end - \} - endCaptures - - 0 - - name - meta.brace.curly.tsx - - - name - meta.object.type.tsx - patterns - - - include - #comment - - - include - #field-declaration - - - include - #method-declaration - - - include - #indexer-declaration - - - include - #type-annotation - - - - type-operator - - match - [.|] - name - keyword.operator.type.tsx - - type-parameters - - begin - ([a-zA-Z_$][\w$]*)?(<) - beginCaptures - - 1 - - name - entity.name.type.tsx - - 2 - - name - meta.brace.angle.tsx - - - end - (?=$)|(>) - endCaptures - - 2 - - name - meta.brace.angle.tsx - - - name - meta.type.parameters.tsx - patterns - - - match - \b(extends)\b - name - keyword.other.tsx - - - include - #comment - - - include - #type - - - - type-paren-or-function-type-parameters - - begin - (?:\b(new)\b)?\s*\( - beginCaptures - - 1 - - name - keyword.control.tsx - - - end - \) - name - meta.type.paren.cover.tsx - patterns - - - include - #comment - - - include - #type - - - include - #function-type-parameters - - - - type-primitive - - captures - - 1 - - name - support.type.tsx - - - match - \b(string|number|boolean|symbol|any|void)\b - name - meta.type.primitive.tsx - - type-tuple - - begin - \[ - beginCaptures - - 0 - - name - meta.brace.square.tsx - - - end - \] - endCaptures - - 0 - - name - meta.brace.square.tsx - - - name - meta.type.tuple.tsx - patterns - - - include - #type - - - include - #comment - - - - undefined-literal - - match - \b(undefined)\b - name - constant.language.tsx - - var-expr - - begin - (?<!\()\s*\b(var|let|const(?!\s+enum))\b - beginCaptures - - 1 - - name - storage.type.tsx - - - end - (?=$|;) - name - meta.var.expr.tsx - patterns - - - include - #var-single-variable - - - include - #comment - - - - var-single-variable - - begin - \b([a-zA-Z_$][\w$]*)\s*(=?) - beginCaptures - - 1 - - name - variable.tsx - - - end - (?=$|[;,]) - name - meta.var-single-variable.expr.tsx - patterns - - - include - #ternary-expression - - - include - #type-annotation - - - include - #string - - - include - #comment - - - include - #expression - - - - variable-initializer - - begin - (=) - beginCaptures - - 1 - - name - keyword.operator.comparison.tsx - - - end - (?=$|[,);=]) - patterns - - - include - #expression - - - - - scopeName - source.tsx - uuid - 805375ec-d614-41f5-8993-5843fe63ea82 - - + ([^>\s]+) + (>) +)? + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + entity.name.type.instance.jsdoc + + 4 + + name + punctuation.definition.bracket.angle.begin.jsdoc + + 5 + + name + constant.other.email.link.underline.jsdoc + + 6 + + name + punctuation.definition.bracket.angle.end.jsdoc + + + + + match + (?x) +((@)borrows) \s+ +((?:[^@\s*/]|\*[^/])+) # <that namepath> +\s+ (as) \s+ # as +((?:[^@\s*/]|\*[^/])+) # <this namepath> + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + entity.name.type.instance.jsdoc + + 4 + + name + keyword.operator.control.jsdoc + + 5 + + name + entity.name.type.instance.jsdoc + + + + + name + meta.example.jsdoc + begin + ((@)example)\s+ + end + (?=@|\*/) + beginCaptures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + + patterns + + + match + ^\s\*\s+ + + + contentName + constant.other.description.jsdoc + begin + \G(<)caption(>) + beginCaptures + + 0 + + name + entity.name.tag.inline.jsdoc + + 1 + + name + punctuation.definition.bracket.angle.begin.jsdoc + + 2 + + name + punctuation.definition.bracket.angle.end.jsdoc + + + end + (</)caption(>)|(?=\*/) + endCaptures + + 0 + + name + entity.name.tag.inline.jsdoc + + 1 + + name + punctuation.definition.bracket.angle.begin.jsdoc + + 2 + + name + punctuation.definition.bracket.angle.end.jsdoc + + + + + match + [^\s@*](?:[^*]|\*[^/])* + captures + + 0 + + name + source.embedded.tsx + + + + + + + match + (?x) ((@)kind) \s+ (class|constant|event|external|file|function|member|mixin|module|namespace|typedef) \b + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + constant.language.symbol-type.jsdoc + + + + + match + (?x) +((@)see) +\s+ +(?: + # URL + ( + (?=https?://) + (?:[^\s*]|\*[^/])+ + ) + | + # JSDoc namepath + ( + (?! + # Avoid matching bare URIs (also acceptable as links) + https?:// + | + # Avoid matching {@inline tags}; we match those below + (?:\[[^\[\]]*\])? # Possible description [preceding]{@tag} + {@(?:link|linkcode|linkplain|tutorial)\b + ) + # Matched namepath + (?:[^@\s*/]|\*[^/])+ + ) +) + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + variable.other.link.underline.jsdoc + + 4 + + name + entity.name.type.instance.jsdoc + + + + + match + (?x) +((@)template) +\s+ +# One or more valid identifiers +( + [A-Za-z_$] # First character: non-numeric word character + [\w$.\[\]]* # Rest of identifier + (?: # Possible list of additional identifiers + \s* , \s* + [A-Za-z_$] + [\w$.\[\]]* + )* +) + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + variable.other.jsdoc + + + + + begin + (?x)((@)template)\s+(?={) + beginCaptures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + + end + (?=\s|\*/|[^{}\[\]A-Za-z_$]) + patterns + + + include + #jsdoctype + + + name + variable.other.jsdoc + match + ([A-Za-z_$][\w$.\[\]]*) + + + + + match + (?x) +( + (@) + (?:arg|argument|const|constant|member|namespace|param|var) +) +\s+ +( + [A-Za-z_$] + [\w$.\[\]]* +) + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + variable.other.jsdoc + + + + + begin + ((@)typedef)\s+(?={) + beginCaptures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + + end + (?=\s|\*/|[^{}\[\]A-Za-z_$]) + patterns + + + include + #jsdoctype + + + name + entity.name.type.instance.jsdoc + match + (?:[^@\s*/]|\*[^/])+ + + + + + begin + ((@)(?:arg|argument|const|constant|member|namespace|param|prop|property|var))\s+(?={) + beginCaptures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + + end + (?=\s|\*/|[^{}\[\]A-Za-z_$]) + patterns + + + include + #jsdoctype + + + name + variable.other.jsdoc + match + ([A-Za-z_$][\w$.\[\]]*) + + + name + variable.other.jsdoc + match + (?x) +(\[)\s* +[\w$]+ +(?: + (?:\[\])? # Foo[ ].bar properties within an array + \. # Foo.Bar namespaced parameter + [\w$]+ +)* +(?: + \s* + (=) # [foo=bar] Default parameter value + \s* + ( + # The inner regexes are to stop the match early at */ and to not stop at escaped quotes + (?> + "(?:(?:\*(?!/))|(?:\\(?!"))|[^*\\])*?" | # [foo="bar"] Double-quoted + '(?:(?:\*(?!/))|(?:\\(?!'))|[^*\\])*?' | # [foo='bar'] Single-quoted + \[ (?:(?:\*(?!/))|[^*])*? \] | # [foo=[1,2]] Array literal + (?:(?:\*(?!/))|\s(?!\s*\])|\[.*?(?:\]|(?=\*/))|[^*\s\[\]])* # Everything else + )* + ) +)? +\s*(?:(\])((?:[^*\s]|\*[^\s/])+)?|(?=\*/)) + captures + + 1 + + name + punctuation.definition.optional-value.begin.bracket.square.jsdoc + + 2 + + name + keyword.operator.assignment.jsdoc + + 3 + + name + source.embedded.tsx + + 4 + + name + punctuation.definition.optional-value.end.bracket.square.jsdoc + + 5 + + name + invalid.illegal.syntax.jsdoc + + + + + + + begin + (?x) +( + (@) + (?:define|enum|exception|export|extends|lends|implements|modifies + |namespace|private|protected|returns?|satisfies|suppress|this|throws|type + |yields?) +) +\s+(?={) + beginCaptures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + + end + (?=\s|\*/|[^{}\[\]A-Za-z_$]) + patterns + + + include + #jsdoctype + + + + + match + (?x) +( + (@) + (?:alias|augments|callback|constructs|emits|event|fires|exports? + |extends|external|function|func|host|lends|listens|interface|memberof!? + |method|module|mixes|mixin|name|requires|see|this|typedef|uses) +) +\s+ +( + (?: + [^{}@\s*] | \*[^/] + )+ +) + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + entity.name.type.instance.jsdoc + + + + + contentName + variable.other.jsdoc + begin + ((@)(?:default(?:value)?|license|version))\s+(([''"])) + beginCaptures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + variable.other.jsdoc + + 4 + + name + punctuation.definition.string.begin.jsdoc + + + end + (\3)|(?=$|\*/) + endCaptures + + 0 + + name + variable.other.jsdoc + + 1 + + name + punctuation.definition.string.end.jsdoc + + + + + match + ((@)(?:default(?:value)?|license|tutorial|variation|version))\s+([^\s*]+) + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + 3 + + name + variable.other.jsdoc + + + + + name + storage.type.class.jsdoc + match + (?x) (@) (?:abstract|access|alias|api|arg|argument|async|attribute|augments|author|beta|borrows|bubbles |callback|chainable|class|classdesc|code|config|const|constant|constructor|constructs|copyright |default|defaultvalue|define|deprecated|desc|description|dict|emits|enum|event|example|exception |exports?|extends|extension(?:_?for)?|external|externs|file|fileoverview|final|fires|for|func |function|generator|global|hideconstructor|host|ignore|implements|implicitCast|inherit[Dd]oc |inner|instance|interface|internal|kind|lends|license|listens|main|member|memberof!?|method |mixes|mixins?|modifies|module|name|namespace|noalias|nocollapse|nocompile|nosideeffects |override|overview|package|param|polymer(?:Behavior)?|preserve|private|prop|property|protected |public|read[Oo]nly|record|require[ds]|returns?|see|since|static|struct|submodule|summary |suppress|template|this|throws|todo|tutorial|type|typedef|unrestricted|uses|var|variation |version|virtual|writeOnce|yields?) \b + captures + + 1 + + name + punctuation.definition.block.tag.jsdoc + + + + + include + #inline-tags + + + match + ((@)(?:[_$[:alpha:]][_$[:alnum:]]*))(?=\s+) + captures + + 1 + + name + storage.type.class.jsdoc + + 2 + + name + punctuation.definition.block.tag.jsdoc + + + + + + brackets + + patterns + + + begin + { + end + }|(?=\*/) + patterns + + + include + #brackets + + + + + begin + \[ + end + \]|(?=\*/) + patterns + + + include + #brackets + + + + + + inline-tags + + patterns + + + name + constant.other.description.jsdoc + match + (\[)[^\]]+(\])(?={@(?:link|linkcode|linkplain|tutorial)) + captures + + 1 + + name + punctuation.definition.bracket.square.begin.jsdoc + + 2 + + name + punctuation.definition.bracket.square.end.jsdoc + + + + + name + entity.name.type.instance.jsdoc + begin + ({)((@)(?:link(?:code|plain)?|tutorial))\s* + beginCaptures + + 1 + + name + punctuation.definition.bracket.curly.begin.jsdoc + + 2 + + name + storage.type.class.jsdoc + + 3 + + name + punctuation.definition.inline.tag.jsdoc + + + end + }|(?=\*/) + endCaptures + + 0 + + name + punctuation.definition.bracket.curly.end.jsdoc + + + patterns + + + match + \G((?=https?://)(?:[^|}\s*]|\*[/])+)(\|)? + captures + + 1 + + name + variable.other.link.underline.jsdoc + + 2 + + name + punctuation.separator.pipe.jsdoc + + + + + match + \G((?:[^{}@\s|*]|\*[^/])+)(\|)? + captures + + 1 + + name + variable.other.description.jsdoc + + 2 + + name + punctuation.separator.pipe.jsdoc + + + + + + + + jsdoctype + + patterns + + + name + invalid.illegal.type.jsdoc + match + \G{(?:[^}*]|\*[^/}])+$ + + + contentName + entity.name.type.instance.jsdoc + begin + \G({) + beginCaptures + + 0 + + name + entity.name.type.instance.jsdoc + + 1 + + name + punctuation.definition.bracket.curly.begin.jsdoc + + + end + ((}))\s*|(?=\*/) + endCaptures + + 1 + + name + entity.name.type.instance.jsdoc + + 2 + + name + punctuation.definition.bracket.curly.end.jsdoc + + + patterns + + + include + #brackets + + + + + + jsx + + patterns + + + include + #jsx-tag-without-attributes-in-expression + + + include + #jsx-tag-in-expression + + + + jsx-tag-without-attributes-in-expression + + begin + (?<!\+\+|--)(?<=[({\[,?=>:*]|&&|\|\||\?|\*\/|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^default|[^\._$[:alnum:]]default|^yield|[^\._$[:alnum:]]yield|^)\s*(?=(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>)) + end + (?!(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>)) + patterns + + + include + #jsx-tag-without-attributes + + + + jsx-tag-without-attributes + + name + meta.tag.without-attributes.tsx + begin + (<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>) + end + (</)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>) + beginCaptures + + 1 + + name + punctuation.definition.tag.begin.tsx + + 2 + + name + entity.name.tag.namespace.tsx + + 3 + + name + punctuation.separator.namespace.tsx + + 4 + + name + entity.name.tag.tsx + + 5 + + name + support.class.component.tsx + + 6 + + name + punctuation.definition.tag.end.tsx + + + endCaptures + + 1 + + name + punctuation.definition.tag.begin.tsx + + 2 + + name + entity.name.tag.namespace.tsx + + 3 + + name + punctuation.separator.namespace.tsx + + 4 + + name + entity.name.tag.tsx + + 5 + + name + support.class.component.tsx + + 6 + + name + punctuation.definition.tag.end.tsx + + + contentName + meta.jsx.children.tsx + patterns + + + include + #jsx-children + + + + jsx-tag-in-expression + + begin + (?x) + (?<!\+\+|--)(?<=[({\[,?=>:*]|&&|\|\||\?|\*\/|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^default|[^\._$[:alnum:]]default|^yield|[^\._$[:alnum:]]yield|^)\s* + (?!<\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s+[^=>])|,)) # look ahead is not type parameter of arrow + (?=(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>)) + end + (?!(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>)) + patterns + + + include + #jsx-tag + + + + jsx-tag + + name + meta.tag.tsx + begin + (?=(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>)) + end + (/>)|(?:(</)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))?\s*(>)) + endCaptures + + 1 + + name + punctuation.definition.tag.end.tsx + + 2 + + name + punctuation.definition.tag.begin.tsx + + 3 + + name + entity.name.tag.namespace.tsx + + 4 + + name + punctuation.separator.namespace.tsx + + 5 + + name + entity.name.tag.tsx + + 6 + + name + support.class.component.tsx + + 7 + + name + punctuation.definition.tag.end.tsx + + + patterns + + + begin + (<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?<!\.|-)(:))?((?:[a-z][a-z0-9]*|([_$[:alpha:]][-_$[:alnum:].]*))(?<!\.|-))(?=((<\s*)|(\s+))(?!\?)|\/?>) + beginCaptures + + 1 + + name + punctuation.definition.tag.begin.tsx + + 2 + + name + entity.name.tag.namespace.tsx + + 3 + + name + punctuation.separator.namespace.tsx + + 4 + + name + entity.name.tag.tsx + + 5 + + name + support.class.component.tsx + + + end + (?=[/]?>) + patterns + + + include + #comment + + + include + #type-arguments + + + include + #jsx-tag-attributes + + + + + begin + (>) + beginCaptures + + 1 + + name + punctuation.definition.tag.end.tsx + + + end + (?=</) + contentName + meta.jsx.children.tsx + patterns + + + include + #jsx-children + + + + + + jsx-children + + patterns + + + include + #jsx-tag-without-attributes + + + include + #jsx-tag + + + include + #jsx-evaluated-code + + + include + #jsx-entities + + + + jsx-evaluated-code + + contentName + meta.embedded.expression.tsx + begin + \{ + end + \} + beginCaptures + + 0 + + name + punctuation.section.embedded.begin.tsx + + + endCaptures + + 0 + + name + punctuation.section.embedded.end.tsx + + + patterns + + + include + #expression + + + + jsx-entities + + patterns + + + name + constant.character.entity.tsx + match + (&)([a-zA-Z0-9]+|#[0-9]+|#x[0-9a-fA-F]+)(;) + captures + + 1 + + name + punctuation.definition.entity.tsx + + 3 + + name + punctuation.definition.entity.tsx + + + + + + jsx-tag-attributes + + name + meta.tag.attributes.tsx + begin + \s+ + end + (?=[/]?>) + patterns + + + include + #comment + + + include + #jsx-tag-attribute-name + + + include + #jsx-tag-attribute-assignment + + + include + #jsx-string-double-quoted + + + include + #jsx-string-single-quoted + + + include + #jsx-evaluated-code + + + include + #jsx-tag-attributes-illegal + + + + jsx-tag-attribute-name + + match + (?x) + \s* + (?:([_$[:alpha:]][-_$[:alnum:].]*)(:))? + ([_$[:alpha:]][-_$[:alnum:]]*) + (?=\s|=|/?>|/\*|//) + captures + + 1 + + name + entity.other.attribute-name.namespace.tsx + + 2 + + name + punctuation.separator.namespace.tsx + + 3 + + name + entity.other.attribute-name.tsx + + + + jsx-tag-attribute-assignment + + name + keyword.operator.assignment.tsx + match + =(?=\s*(?:'|"|{|/\*|//|\n)) + + jsx-string-double-quoted + + name + string.quoted.double.tsx + begin + " + end + " + beginCaptures + + 0 + + name + punctuation.definition.string.begin.tsx + + + endCaptures + + 0 + + name + punctuation.definition.string.end.tsx + + + patterns + + + include + #jsx-entities + + + + jsx-string-single-quoted + + name + string.quoted.single.tsx + begin + ' + end + ' + beginCaptures + + 0 + + name + punctuation.definition.string.begin.tsx + + + endCaptures + + 0 + + name + punctuation.definition.string.end.tsx + + + patterns + + + include + #jsx-entities + + + + jsx-tag-attributes-illegal + + name + invalid.illegal.attribute.tsx + match + \S+ + + + + \ No newline at end of file diff --git a/TypeScriptReact.tmTheme b/TypeScriptReact.tmTheme new file mode 100644 index 00000000..803fe27f --- /dev/null +++ b/TypeScriptReact.tmTheme @@ -0,0 +1,283 @@ + + + + + name + TypeScriptReact + uuid + 8B704EF9-AF8E-402F-933C-1D46D8C49E58 + settings + + + scope + storage.modifier, storage.type, keyword.other, keyword.operator.expression, keyword.operator.new, keyword.generator.asterisk, punctuation.definition.template-expression + settings + + vsclassificationtype + keyword + + + + scope + constant.language, variable.language + settings + + vsclassificationtype + keyword + + + + scope + keyword.control, keyword.operator.expression.delete, keyword.other.using, keyword.other.operator, entity.name.operator + settings + + vsclassificationtype + keyword - control + + + + scope + support.class, support.type, entity.name.type, entity.name.namespace, entity.other.attribute, entity.name.scope-resolution, entity.name.class + settings + + vsclassificationtype + type + + + + scope + string, punctuation.definition.string, constant.character + settings + + vsclassificationtype + string + + + + scope + keyword.control.anchor.regexp, keyword.other.back-reference.regexp, keyword.operator.quantifier.regexp, keyword.operator.or.regexp, keyword.operator.negation.regexp, punctuation.definition.group.regexp, punctuation.definition.group.assertion.regexp, meta.assertion.look-ahead.regexp, meta.assertion.negative-look-ahead.regexp, punctuation.definition.group.capture.regexp, punctuation.definition.character-class.regexp, constant.other.character-class.range.regexp + settings + + vsclassificationtype + string + + + + scope + constant.numeric, meta.delimiter.decimal.period.tsx, constant.language.nan.tsx, constant.language.infinity.tsx + settings + + vsclassificationtype + number + + + + scope + keyword.operator, storage.type.function.arrow.tsx + settings + + vsclassificationtype + operator + + + + scope + meta.brace.angle.tsx, meta.brace.round.tsx, meta.brace.square.tsx, punctuation, constant.language.import-export-all.tsx, meta.delimiter.object.comma.tsx + settings + + vsclassificationtype + punctuation + + + + scope + comment, comment.block.tsx, comment.line.double-slash.tsx, punctuation.definition.comment.tsx + settings + + vsclassificationtype + comment + + + + scope + comment.block.documentation.tsx, other.meta.jsdoc, other.description.jsdoc + settings + + vsclassificationtype + comment + + + + scope + entity.name.type.instance.jsdoc + settings + + vsclassificationtype + identifier + + + + scope + entity.name.type.class.tsx + settings + + vsclassificationtype + class name + + + + scope + entity.name.type.module.tsx + settings + + vsclassificationtype + module name + + + + scope + entity.name.type.enum.tsx + settings + + vsclassificationtype + enum name + + + + scope + meta.template.expression.tsx, entity.other.inherited-class.tsx + settings + + vsclassificationtype + identifier + + + + scope + variable, meta.definition.variable.name, support.variable, entity.name.variable, constant.other.placeholder + settings + + vsclassificationtype + local name + + + + scope + entity.name.function, support.function, support.constant.handlebars, source.powershell variable.other.member, entity.name.operator.custom-literal + settings + + vsclassificationtype + method name + + + + scope + variable.language.arguments.tsx, support.type.object + settings + + vsclassificationtype + identifier + + + + scope + entity.name.tag.inline, entity.name.tag.directive + settings + + vsclassificationtype + HTML Element Name + + + + scope + entity.other.attribute-name + settings + + vsclassificationtype + HTML Attribute Name + + + + scope + meta.tag string.quoted, meta.tag string.quoted punctuation.definition.string, meta.tag string.quoted + settings + + vsclassificationtype + string + + + + scope + meta.object-literal.key + settings + + vsclassificationtype + parameter name + + + + scope + constant.character.escape + settings + + vsclassificationtype + string - escape character + + + + scope + entity.name.label + settings + + vsclassificationtype + label name + + + + scope + meta.tag string.quoted constant.character.entity.tsx, meta.tag string.quoted constant.character.entity.tsx punctuation.definition.entity.tsx + settings + + vsclassificationtype + xml literal - attribute value + + + + scope + meta.jsx.children.tsx, constant.character.entity.tsx, punctuation.definition.entity.tsx, invalid.illegal.bad-ampersand.tsx + settings + + vsclassificationtype + xml literal - text + + + + scope + invalid.illegal.attribute.tsx + settings + + vsclassificationtype + identifier + + + + scope + punctuation.definition.tag + settings + + vsclassificationtype + html operator + + + + scope + meta.tag + settings + + vsclassificationtype + HTML Element Name + + + + + \ No newline at end of file diff --git a/appveyor.yml b/appveyor.yml deleted file mode 100644 index 154151e4..00000000 --- a/appveyor.yml +++ /dev/null @@ -1,16 +0,0 @@ -# Test against this version of Node.js -environment: - nodejs_version: "4" - -# Install scripts. (runs after repo cloning) -install: - - ps: Install-Product node $env:nodejs_version - - node --version - - npm install -g npm@next - - npm --version - - cd tests - - npm install - - npm test - -# Don't actually build. -build: off diff --git a/build/build.ts b/build/build.ts new file mode 100644 index 00000000..a7fbc6f0 --- /dev/null +++ b/build/build.ts @@ -0,0 +1,170 @@ +import fs = require('fs'); +import path = require('path'); +import yaml = require('js-yaml'); +import plist = require('plist'); + +enum Language { + TypeScript = "TypeScript", + TypeScriptReact = "TypeScriptReact" +} + +enum Extension { + TmLanguage = "tmLanguage", + TmTheme = "tmTheme", + YamlTmLanguage = "YAML-tmLanguage", + YamlTmTheme = "YAML-tmTheme" +} + +function file(language: Language, extension: Extension) { + return path.join(__dirname, '..', `${language}.${extension}`); +} + +function writePlistFile(grammar: TmGrammar | TmTheme, fileName: string) { + const text = plist.build(grammar); + fs.writeFileSync(fileName, text); +} + +function readYaml(fileName: string) { + const text = fs.readFileSync(fileName, "utf8"); + return yaml.load(text); +} + +function changeTsToTsx(str: string) { + return str.replace(/\.ts/g, '.tsx'); +} + +function transformGrammarRule(rule: any, propertyNames: string[], transformProperty: (ruleProperty: string) => string) { + for (const propertyName of propertyNames) { + const value = rule[propertyName]; + if (typeof value === 'string') { + rule[propertyName] = transformProperty(value); + } + } + + for (var propertyName in rule) { + const value = rule[propertyName]; + if (typeof value === 'object') { + transformGrammarRule(value, propertyNames, transformProperty); + } + } +} + +function transformGrammarRepository(grammar: TmGrammar, propertyNames: string[], transformProperty: (ruleProperty: string) => string) { + const repository = grammar.repository; + for (let key in repository) { + transformGrammarRule(repository[key], propertyNames, transformProperty); + } +} + +function getTsxGrammar() { + let variables: MapLike; + const tsxUpdatesBeforeTransformation = readYaml(file(Language.TypeScriptReact, Extension.YamlTmLanguage)) as TmGrammar; + const grammar = getTsGrammar(tsGrammarVariables => { + variables = tsGrammarVariables; + for (const variableName in tsxUpdatesBeforeTransformation.variables) { + variables[variableName] = tsxUpdatesBeforeTransformation.variables[variableName]; + } + return variables; + }); + const tsxUpdates = updateGrammarVariables(tsxUpdatesBeforeTransformation, variables!); + + // Update name, file types, scope name and uuid + grammar.name = tsxUpdates.name; + grammar.scopeName = tsxUpdates.scopeName; + grammar.fileTypes = tsxUpdates.fileTypes; + grammar.uuid = tsxUpdates.uuid; + + // Update scope names to .tsx + transformGrammarRepository(grammar, ["name", "contentName"], changeTsToTsx); + + // Add repository items + const repository = grammar.repository; + const updatesRepository = tsxUpdates.repository; + for (let key in updatesRepository) { + switch(key) { + case "expressionWithoutIdentifiers": + // Update expression + (repository[key] as TmGrammarRepositoryPatterns).patterns.unshift((updatesRepository[key] as TmGrammarRepositoryPatterns).patterns[0]); + break; + default: + // Add jsx + repository[key] = updatesRepository[key]; + } + } + + return grammar; +} + +function getTsGrammar(getVariables: (tsGrammarVariables: MapLike) => MapLike) { + const tsGrammarBeforeTransformation = readYaml(file(Language.TypeScript, Extension.YamlTmLanguage)) as TmGrammar; + return updateGrammarVariables(tsGrammarBeforeTransformation, getVariables(tsGrammarBeforeTransformation.variables as MapLike)); +} + +function replacePatternVariables(pattern: string, variableReplacers: VariableReplacer[]) { + let result = pattern; + for (const [variableName, value] of variableReplacers) { + result = result.replace(variableName, value); + } + return result; +} + +type VariableReplacer = [RegExp, string]; +function updateGrammarVariables(grammar: TmGrammar, variables: MapLike) { + delete grammar.variables; + const variableReplacers: VariableReplacer[] = []; + for (const variableName in variables) { + // Replace the pattern with earlier variables + const pattern = replacePatternVariables(variables[variableName], variableReplacers); + variableReplacers.push([new RegExp(`{{${variableName}}}`, "gim"), pattern]); + } + transformGrammarRepository( + grammar, + ["begin", "end", "match"], + pattern => replacePatternVariables(pattern, variableReplacers) + ); + return grammar; +} + +function buildGrammar() { + const tsGrammar = getTsGrammar(grammarVariables => grammarVariables); + + // Write TypeScript.tmLanguage + writePlistFile(tsGrammar, file(Language.TypeScript, Extension.TmLanguage)); + + // Write TypeScriptReact.tmLangauge + const tsxGrammar = getTsxGrammar(); + writePlistFile(tsxGrammar, file(Language.TypeScriptReact, Extension.TmLanguage)); +} + +function changeTsToTsxTheme(theme: TmTheme) { + const tsxUpdates = readYaml(file(Language.TypeScriptReact, Extension.YamlTmTheme)) as TmTheme; + + // Update name, uuid + theme.name = tsxUpdates.name; + theme.uuid = tsxUpdates.uuid; + + // Update scope names to .tsx + const settings = theme.settings; + for (let i = 0; i < settings.length; i++) { + settings[i].scope = changeTsToTsx(settings[i].scope); + } + + // Add additional setting items + theme.settings = theme.settings.concat(tsxUpdates.settings); + + return theme; +} + +function buildTheme() { + const tsTheme = readYaml(file(Language.TypeScript, Extension.YamlTmTheme)) as TmTheme; + + // Write TypeScript.tmTheme + writePlistFile(tsTheme, file(Language.TypeScript, Extension.TmTheme)); + + // Write TypeScriptReact.thTheme + const tsxTheme = changeTsToTsxTheme(tsTheme); + writePlistFile(tsxTheme, file(Language.TypeScriptReact, Extension.TmTheme)); +} + +buildGrammar(); +buildTheme(); \ No newline at end of file diff --git a/build/index.d.ts b/build/index.d.ts new file mode 100644 index 00000000..6c0ca790 --- /dev/null +++ b/build/index.d.ts @@ -0,0 +1,54 @@ +declare module "plist" { + export function build(json: any): string; +} + +declare interface MapLike { + [s: string]: T; +} + +declare interface TmGrammarRuleName { + name: string; +} + +declare interface TmGrammarRule { + name?: string; +} +declare interface TmGrammarMatchRule extends TmGrammarRule { + match: string; + captures: MapLike; +} +declare interface TmGrammarBeginEndRule extends TmGrammarRule { + contentName?: string; + begin: string; + end: string; + beginCaptures?: MapLike; + endCaptures?: MapLike; + patterns: AnyTmGrammarRule[]; +} +declare interface TmGrammarIncludeRule extends TmGrammarRule { + include: string; +} +declare type AnyTmGrammarRule = TmGrammarMatchRule | TmGrammarBeginEndRule | TmGrammarIncludeRule; +declare interface TmGrammarRepositoryPatterns { + patterns: AnyTmGrammarRule[]; +} +declare type TmGrammarRepositaryRule = AnyTmGrammarRule | TmGrammarRepositoryPatterns; +declare interface TmGrammar { + name: string; + scopeName: string; + fileTypes: string[]; + uuid: string; + variables?: MapLike; + patterns?: AnyTmGrammarRule[]; + repository: MapLike; +} + +declare interface TmThemeSetting { + scope: string; + settings: { vsclassificationtype: string; }; +} +declare interface TmTheme { + name: string; + uuid: string; + settings: TmThemeSetting[]; +} \ No newline at end of file diff --git a/build/tsconfig.json b/build/tsconfig.json new file mode 100644 index 00000000..698a3eb2 --- /dev/null +++ b/build/tsconfig.json @@ -0,0 +1,12 @@ +{ + "compilerOptions": { + "lib": ["ES2023"], + "target": "ES2023", + "module": "nodenext", + "strict": true, + "skipLibCheck": true + }, + "exclude": [ + "node_modules" + ] +} diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 00000000..86f1037a --- /dev/null +++ b/package-lock.json @@ -0,0 +1,988 @@ +{ + "name": "typescript-tmlanguage", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "typescript-tmlanguage", + "version": "1.0.0", + "devDependencies": { + "@types/js-yaml": "^4.0.9", + "@types/node": "^24.10.1", + "cpx2": "^8.0.0", + "cross-env": "^10.1.0", + "js-yaml": "^4.1.1", + "plist": "^3.1.0", + "typescript": "^5.9.3", + "vscode-oniguruma": "^2.0.1", + "vscode-textmate": "^9.2.1" + }, + "engines": { + "node": ">= 20.9" + } + }, + "node_modules/@epic-web/invariant": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@epic-web/invariant/-/invariant-1.0.0.tgz", + "integrity": "sha512-lrTPqgvfFQtR/eY/qkIzp98OGdNJu0m5ji3q/nJI8v3SXkRKEnWiOxMmbvcSoAIzv/cGiuvRy57k4suKQSAdwA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@isaacs/cliui": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", + "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", + "dev": true, + "license": "ISC", + "dependencies": { + "string-width": "^5.1.2", + "string-width-cjs": "npm:string-width@^4.2.0", + "strip-ansi": "^7.0.1", + "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", + "wrap-ansi": "^8.1.0", + "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@types/js-yaml": { + "version": "4.0.9", + "resolved": "https://registry.npmjs.org/@types/js-yaml/-/js-yaml-4.0.9.tgz", + "integrity": "sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "24.10.1", + "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.1.tgz", + "integrity": "sha512-GNWcUTRBgIRJD5zj+Tq0fKOJ5XZajIiBroOF0yvj2bSU1WvNdYS/dn9UxwsujGW4JX06dnHyjV2y9rRaybH0iQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~7.16.0" + } + }, + "node_modules/@xmldom/xmldom": { + "version": "0.8.11", + "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.8.11.tgz", + "integrity": "sha512-cQzWCtO6C8TQiYl1ruKNn2U6Ao4o4WBBcbL61yJl84x+j5sOWWFU9X7DpND8XZG3daDppSsigMdfAIl2upQBRw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/ansi-regex": { + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz", + "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/ansi-styles": { + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz", + "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, + "license": "Python-2.0" + }, + "node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/brace-expansion": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", + "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "license": "MIT" + }, + "node_modules/cpx2": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/cpx2/-/cpx2-8.0.0.tgz", + "integrity": "sha512-RxD9jrSVNSOmfcbiPlr3XnKbUKH9K1w2HCv0skczUKhsZTueiDBecxuaSAKQkYSLQaGVA4ZQJZlTj5hVNNEvKg==", + "dev": true, + "license": "MIT", + "dependencies": { + "debounce": "^2.0.0", + "debug": "^4.1.1", + "duplexer": "^0.1.1", + "fs-extra": "^11.1.0", + "glob": "^11.0.0", + "glob2base": "0.0.12", + "ignore": "^6.0.2", + "minimatch": "^10.0.1", + "p-map": "^7.0.0", + "resolve": "^1.12.0", + "safe-buffer": "^5.2.0", + "shell-quote": "^1.8.0", + "subarg": "^1.0.0" + }, + "bin": { + "cpx": "bin/index.js" + }, + "engines": { + "node": "^20.0.0 || >=22.0.0", + "npm": ">=10" + } + }, + "node_modules/cross-env": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/cross-env/-/cross-env-10.1.0.tgz", + "integrity": "sha512-GsYosgnACZTADcmEyJctkJIoqAhHjttw7RsFrVoJNXbsWWqaq6Ym+7kZjq6mS45O0jij6vtiReppKQEtqWy6Dw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@epic-web/invariant": "^1.0.0", + "cross-spawn": "^7.0.6" + }, + "bin": { + "cross-env": "dist/bin/cross-env.js", + "cross-env-shell": "dist/bin/cross-env-shell.js" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/debounce": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/debounce/-/debounce-2.2.0.tgz", + "integrity": "sha512-Xks6RUDLZFdz8LIdR6q0MTH44k7FikOmnh5xkSjMig6ch45afc8sjTjRQf3P6ax8dMgcQrYO/AR2RGWURrruqw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/duplexer": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz", + "integrity": "sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==", + "dev": true, + "license": "MIT" + }, + "node_modules/eastasianwidth": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", + "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==", + "dev": true, + "license": "MIT" + }, + "node_modules/emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==", + "dev": true, + "license": "MIT" + }, + "node_modules/find-index": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/find-index/-/find-index-0.1.1.tgz", + "integrity": "sha512-uJ5vWrfBKMcE6y2Z8834dwEZj9mNGxYa3t3I53OwFeuZ8D9oc2E5zcsrkuhX6h4iYrjhiv0T3szQmxlAV9uxDg==", + "dev": true, + "license": "MIT" + }, + "node_modules/foreground-child": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz", + "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==", + "dev": true, + "license": "ISC", + "dependencies": { + "cross-spawn": "^7.0.6", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/fs-extra": { + "version": "11.3.2", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.2.tgz", + "integrity": "sha512-Xr9F6z6up6Ws+NjzMCZc6WXg2YFRlrLP9NQDO3VQrWrfiojdhS56TzueT88ze0uBdCTwEIhQ3ptnmKeWGFAe0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=14.14" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/glob": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-11.1.0.tgz", + "integrity": "sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "foreground-child": "^3.3.1", + "jackspeak": "^4.1.1", + "minimatch": "^10.1.1", + "minipass": "^7.1.2", + "package-json-from-dist": "^1.0.0", + "path-scurry": "^2.0.0" + }, + "bin": { + "glob": "dist/esm/bin.mjs" + }, + "engines": { + "node": "20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob2base": { + "version": "0.0.12", + "resolved": "https://registry.npmjs.org/glob2base/-/glob2base-0.0.12.tgz", + "integrity": "sha512-ZyqlgowMbfj2NPjxaZZ/EtsXlOch28FRXgMd64vqZWk1bT9+wvSRLYD1om9M7QfQru51zJPAT17qXm4/zd+9QA==", + "dev": true, + "dependencies": { + "find-index": "^0.1.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/ignore": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-6.0.2.tgz", + "integrity": "sha512-InwqeHHN2XpumIkMvpl/DCJVrAHgCsG5+cn1XlnLWGwtZBm8QJfSusItfrwx81CTp5agNZqpKU2J/ccC5nGT4A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/is-core-module": { + "version": "2.16.1", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz", + "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", + "dev": true, + "license": "MIT", + "dependencies": { + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/jackspeak": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.1.1.tgz", + "integrity": "sha512-zptv57P3GpL+O0I7VdMJNBZCu+BPHVQUk55Ft8/QCJjTVxrnJHuVuX/0Bl2A6/+2oyR/ZMEuFKwmzqqZ/U5nPQ==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "@isaacs/cliui": "^8.0.2" + }, + "engines": { + "node": "20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/js-yaml": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz", + "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsonfile": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/lru-cache": { + "version": "11.2.2", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.2.tgz", + "integrity": "sha512-F9ODfyqML2coTIsQpSkRHnLSZMtkU8Q+mSfcaIyKwy58u+8k5nvAYeiNhsyMARvzNcXJ9QfWVrcPsC9e9rAxtg==", + "dev": true, + "license": "ISC", + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/minimatch": { + "version": "10.2.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", + "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/minipass": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz", + "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/p-map": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/p-map/-/p-map-7.0.4.tgz", + "integrity": "sha512-tkAQEw8ysMzmkhgw8k+1U/iPhWNhykKnSk4Rd5zLoPJCuJaGRPo6YposrZgaxHKzDHdDWWZvE/Sk7hsL2X/CpQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/package-json-from-dist": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz", + "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==", + "dev": true, + "license": "BlueOak-1.0.0" + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true, + "license": "MIT" + }, + "node_modules/path-scurry": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.1.tgz", + "integrity": "sha512-oWyT4gICAu+kaA7QWk/jvCHWarMKNs6pXOGWKDTr7cw4IGcUbW+PeTfbaQiLGheFRpjo6O9J0PmyMfQPjH71oA==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" + }, + "engines": { + "node": "20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/plist": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/plist/-/plist-3.1.0.tgz", + "integrity": "sha512-uysumyrvkUX0rX/dEVqt8gC3sTBzd4zoWfLeS29nb53imdaXVvLINYXTI2GNqzaMuvacNx4uJQ8+b3zXR0pkgQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@xmldom/xmldom": "^0.8.8", + "base64-js": "^1.5.1", + "xmlbuilder": "^15.1.1" + }, + "engines": { + "node": ">=10.4.0" + } + }, + "node_modules/resolve": { + "version": "1.22.11", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz", + "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-core-module": "^2.16.1", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/shell-quote": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.3.tgz", + "integrity": "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/string-width-cjs": { + "name": "string-width", + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width-cjs/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true, + "license": "MIT" + }, + "node_modules/string-width-cjs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz", + "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/strip-ansi-cjs": { + "name": "strip-ansi", + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/subarg": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/subarg/-/subarg-1.0.0.tgz", + "integrity": "sha512-RIrIdRY0X1xojthNcVtgT9sjpOGagEUKpZdgBUi054OEPFo282yg+zE+t1Rj3+RqKq2xStL7uUHhY+AjbC4BXg==", + "dev": true, + "license": "MIT", + "dependencies": { + "minimist": "^1.1.0" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "7.16.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz", + "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==", + "dev": true, + "license": "MIT" + }, + "node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/vscode-oniguruma": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/vscode-oniguruma/-/vscode-oniguruma-2.0.1.tgz", + "integrity": "sha512-poJU8iHIWnC3vgphJnrLZyI3YdqRlR27xzqDmpPXYzA93R4Gk8z7T6oqDzDoHjoikA2aS82crdXFkjELCdJsjQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/vscode-textmate": { + "version": "9.2.1", + "resolved": "https://registry.npmjs.org/vscode-textmate/-/vscode-textmate-9.2.1.tgz", + "integrity": "sha512-eXiUi2yYFv9bdvgrYtJynA7UemCEkpVNE50S9iBBA08LYG5t9+/TB+8IRS/YoYOubCez2OkSyZ1Q12eQMwzbrw==", + "dev": true, + "license": "MIT" + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/wrap-ansi": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", + "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^6.1.0", + "string-width": "^5.0.1", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs": { + "name": "wrap-ansi", + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true, + "license": "MIT" + }, + "node_modules/wrap-ansi-cjs/node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/xmlbuilder": { + "version": "15.1.1", + "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz", + "integrity": "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.0" + } + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 00000000..fae3a9b1 --- /dev/null +++ b/package.json @@ -0,0 +1,29 @@ +{ + "name": "typescript-tmlanguage", + "version": "1.0.0", + "private": true, + "description": "TextMate grammar files for TypeScript for VS Code, Sublime Text, and Atom", + "scripts": { + "build": "npm run build:grammar && npm run build:tests", + "build:grammar": "tsc -b build -v && node build/build.js", + "build:tests": "tsc -b tests -v", + "pretest": "npm run build", + "test": "node --test tests/test.js", + "diff": "cross-env-shell $DIFF tests/baselines tests/generated", + "accept": "cpx 'tests/generated/*' tests/baselines" + }, + "devDependencies": { + "@types/js-yaml": "^4.0.9", + "@types/node": "^24.10.1", + "cpx2": "^8.0.0", + "cross-env": "^10.1.0", + "js-yaml": "^4.1.1", + "plist": "^3.1.0", + "typescript": "^5.9.3", + "vscode-oniguruma": "^2.0.1", + "vscode-textmate": "^9.2.1" + }, + "engines": { + "node": ">= 20.9" + } +} diff --git a/tests/.tsdrc b/tests/.tsdrc deleted file mode 100644 index db487564..00000000 --- a/tests/.tsdrc +++ /dev/null @@ -1,3 +0,0 @@ -{ - "token": "d7a61a9936743d97a2ebcea2de1cc0637c05e57b" -} diff --git a/tests/baselines/Abstracts.baseline.txt b/tests/baselines/Abstracts.baseline.txt new file mode 100644 index 00000000..ea320fad --- /dev/null +++ b/tests/baselines/Abstracts.baseline.txt @@ -0,0 +1,274 @@ +original file +----------------------------------- +abstract class Animal { + public age: number; + public yearsLeft() { return 20 - this.age; } + abstract makeSound(): string; +} + +class Cow extends Animal { + makeSound() { return "Moo"; } +} + +class Cat extends Animal { + makeSound() { return "Meow"; } +} + +let cow = new Cow(); +cow.makeSound(); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>abstract class Animal { + ^^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> public age: number; + ^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public yearsLeft() { return 20 - this.age; } + ^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> abstract makeSound(): string; + ^^^ + source.ts meta.class.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>class Cow extends Animal { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> makeSound() { return "Moo"; } + ^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>class Cat extends Animal { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> makeSound() { return "Meow"; } + ^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>let cow = new Cow(); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>cow.makeSound(); + ^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Abstracts.txt b/tests/baselines/Abstracts.txt deleted file mode 100644 index 0f1480f2..00000000 --- a/tests/baselines/Abstracts.txt +++ /dev/null @@ -1,2 +0,0 @@ -[1, 1]: source.ts meta.declaration.object.ts storage.modifier.ts -[4, 4]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts diff --git a/tests/baselines/ArrowFunctionInsideTypeAssertion.baseline.txt b/tests/baselines/ArrowFunctionInsideTypeAssertion.baseline.txt new file mode 100644 index 00000000..14d44865 --- /dev/null +++ b/tests/baselines/ArrowFunctionInsideTypeAssertion.baseline.txt @@ -0,0 +1,406 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has type assertion +// Issue: https://github.com/Microsoft/TypeScript-Sublime-Plugin/issues/292 + +var object = { + setTransform: <(domNode: HTMLElement, desiredValue: string) => void>null, + setDisplay: (domNode: HTMLElement, desiredValue: string) => { + if (domNode.style.display !== desiredValue) { + domNode.style.display = desiredValue; + } + } +} + +function f(x: string | ((value: string) => number)) { + if (typeof x === "string") { + return +x + } + else { + let f = <(v: string) => number> x + return f("hello world") + } +} + + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has type assertion + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>// Issue: https://github.com/Microsoft/TypeScript-Sublime-Plugin/issues/292 + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +> + ^ + source.ts +>var object = { + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> setTransform: <(domNode: HTMLElement, desiredValue: string) => void>null, + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.ts meta.parameters.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.return.ts + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts cast.expr.ts meta.brace.angle.ts + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts constant.language.null.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> setDisplay: (domNode: HTMLElement, desiredValue: string) => { + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.parameters.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> if (domNode.style.display !== desiredValue) { + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> domNode.style.display = desiredValue; + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> + ^ + source.ts +>function f(x: string | ((value: string) => number)) { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts + ^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> if (typeof x === "string") { + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.operator.expression.typeof.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> return +x + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts variable.other.readwrite.ts +> } + ^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> else { + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> let f = <(v: string) => number> x + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts cast.expr.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts cast.expr.ts meta.type.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts cast.expr.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts cast.expr.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts cast.expr.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts cast.expr.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts cast.expr.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts cast.expr.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts cast.expr.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts cast.expr.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts +> return f("hello world") + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.brace.round.ts +> } + ^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/ArrowFunctionInsideTypeAssertion.txt b/tests/baselines/ArrowFunctionInsideTypeAssertion.txt deleted file mode 100644 index 1d37a855..00000000 --- a/tests/baselines/ArrowFunctionInsideTypeAssertion.txt +++ /dev/null @@ -1,17 +0,0 @@ -[4, 19]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.block.ts meta.object.member.ts cast.expr.ts meta.brace.angle.ts -[4, 20]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.block.ts meta.object.member.ts cast.expr.ts meta.type.paren.cover.ts -[4, 21]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.block.ts meta.object.member.ts cast.expr.ts meta.type.paren.cover.ts meta.type.name.ts -[4, 30]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.block.ts meta.object.member.ts cast.expr.ts meta.type.paren.cover.ts meta.type.name.ts -[4, 43]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.block.ts meta.object.member.ts cast.expr.ts meta.type.paren.cover.ts meta.type.name.ts -[4, 57]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.block.ts meta.object.member.ts cast.expr.ts meta.type.paren.cover.ts meta.type.primitive.ts support.type.ts -[4, 65]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.block.ts meta.object.member.ts cast.expr.ts meta.type.function.return.ts keyword.operator.ts -[4, 68]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.block.ts meta.object.member.ts cast.expr.ts meta.type.function.return.ts meta.type.primitive.ts support.type.ts -[4, 73]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.block.ts meta.object.member.ts constant.language.null.ts -[17, 17]: source.ts meta.function.ts meta.decl.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts cast.expr.ts meta.brace.angle.ts -[17, 18]: source.ts meta.function.ts meta.decl.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts cast.expr.ts meta.type.paren.cover.ts -[17, 19]: source.ts meta.function.ts meta.decl.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts cast.expr.ts meta.type.paren.cover.ts meta.type.name.ts -[17, 22]: source.ts meta.function.ts meta.decl.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts cast.expr.ts meta.type.paren.cover.ts meta.type.primitive.ts support.type.ts -[17, 30]: source.ts meta.function.ts meta.decl.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts cast.expr.ts meta.type.function.return.ts keyword.operator.ts -[17, 33]: source.ts meta.function.ts meta.decl.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts cast.expr.ts meta.type.function.return.ts meta.type.primitive.ts support.type.ts -[17, 39]: source.ts meta.function.ts meta.decl.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts cast.expr.ts meta.brace.angle.ts -[17, 41]: source.ts meta.function.ts meta.decl.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts \ No newline at end of file diff --git a/tests/baselines/AsConstSatisfies.baseline.txt b/tests/baselines/AsConstSatisfies.baseline.txt new file mode 100644 index 00000000..1bacd959 --- /dev/null +++ b/tests/baselines/AsConstSatisfies.baseline.txt @@ -0,0 +1,48 @@ +original file +----------------------------------- +let a = {} as const satisfies {}; + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let a = {} as const satisfies {}; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts keyword.control.as.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts keyword.control.satisfies.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Comments.baseline.txt b/tests/baselines/Comments.baseline.txt new file mode 100644 index 00000000..0b0449d0 --- /dev/null +++ b/tests/baselines/Comments.baseline.txt @@ -0,0 +1,2246 @@ +original file +----------------------------------- +/* +Tests for comments in general. + +Pull requests: + - https://github.com/Microsoft/TypeScript-Sublime-Plugin/pull/307 + - https://github.com/Microsoft/TypeScript-Sublime-Plugin/pull/308 +*/ + +var /* comment */ x: string = "yahoo"; +var x /* comment */: string = "yahoo"; +var x: /* comment */ string = "yahoo"; +var x: string /* comment */ = "yahoo"; +var x: string = /* comment */ "yahoo"; +var x: string = "yahoo" /* comment */; +var x: string = "yahoo"; /* comment */ + +var /* comment */ x: string = "yahoo" +var x /* comment */: string = "yahoo" +var x: /* comment */ string = "yahoo" +var x: string /* comment */ = "yahoo" +var x: string = /* comment */ "yahoo" +var x: string = "yahoo" /* comment */ + +/**/ interface i extends i1, i2, i3 {} +interface /**/ i extends i1, i2, i3 {} +interface i /**/ extends i1, i2, i3 {} +interface i extends /**/ i1, i2, i3 {} +interface i extends i1 /**/, i2, i3 {} +interface i extends i1, /**/ i2, i3 {} +interface i extends i1, i2 /**/, i3 {} +interface i extends i1, i2, /**/ i3 {} +interface i extends i1, i2, i3 /**/ {} +/**/ interface /**/ i /**/ extends /**/ i1, /**/ i2, /**/ i3 /**/ {} +/**/ interface /**/ i /**/ extends /**/ i1 /**/ , /**/ i2 /**/ , /**/ i3 /**/ {} + +/**/class i extends c1,c2,c3{} +class/**/i extends c1,c2,c3{} +class i/**/extends c1,c2,c3{} +class i extends/**/c1,c2,c3{} +class i extends c1/**/,c2,c3{} +class i extends c1,/**/c2,c3{} +class i extends c1,c2/**/,c3{} +class i extends c1,c2,/**/c3{} +class i extends c1,c2,c3/**/{} +/**/class/**/i/**/extends/**/c1,/**/c2,/**/c3/**/{} +/**/class/**/i/**/extends/**/c1/**/,/**/c2/**/,/**/c3/**/{} + +interface KeyValuePair/**/ extends Array { 0: K; 1: V; } +interface KeyValuePair/**/extends Array { 0: K; 1: V; } +interface KeyValuePair extends/**/Array { 0: K; 1: V; } +interface KeyValuePair extends Array/**/ { 0: K; 1: V; } +interface KeyValuePair extends Array/**/{ 0: K; 1: V; } + +interface G/**/ { + f(x: V): V; +} +interface G { + f(x: V): V; +} +interface G { + f(x: V): V; +} + +var x/*comments*/=new String(); +var x=/*comments*/new String(); +var x= new/*comments*/String(); + +var x /* comments */ = new String(); +var x = /* comments */ new String(); +var x = new /* comments */ String(); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/* + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +>Tests for comments in general. + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts +> + ^ + source.ts comment.block.ts +>Pull requests: + ^^^^^^^^^^^^^^^ + source.ts comment.block.ts +> - https://github.com/Microsoft/TypeScript-Sublime-Plugin/pull/307 + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts +> - https://github.com/Microsoft/TypeScript-Sublime-Plugin/pull/308 + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts +>*/ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +> + ^ + source.ts +>var /* comment */ x: string = "yahoo"; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>var x /* comment */: string = "yahoo"; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>var x: /* comment */ string = "yahoo"; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>var x: string /* comment */ = "yahoo"; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>var x: string = /* comment */ "yahoo"; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>var x: string = "yahoo" /* comment */; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts punctuation.terminator.statement.ts +>var x: string = "yahoo"; /* comment */ + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +> + ^ + source.ts +>var /* comment */ x: string = "yahoo" + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts +>var x /* comment */: string = "yahoo" + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts +>var x: /* comment */ string = "yahoo" + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts +>var x: string /* comment */ = "yahoo" + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts +>var x: string = /* comment */ "yahoo" + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts +>var x: string = "yahoo" /* comment */ + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts +> + ^ + source.ts +>/**/ interface i extends i1, i2, i3 {} + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface /**/ i extends i1, i2, i3 {} + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface i /**/ extends i1, i2, i3 {} + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface i extends /**/ i1, i2, i3 {} + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface i extends i1 /**/, i2, i3 {} + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface i extends i1, /**/ i2, i3 {} + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface i extends i1, i2 /**/, i3 {} + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface i extends i1, i2, /**/ i3 {} + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface i extends i1, i2, i3 /**/ {} + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>/**/ interface /**/ i /**/ extends /**/ i1, /**/ i2, /**/ i3 /**/ {} + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>/**/ interface /**/ i /**/ extends /**/ i1 /**/ , /**/ i2 /**/ , /**/ i3 /**/ {} + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts entity.other.inherited-class.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> + ^ + source.ts +>/**/class i extends c1,c2,c3{} + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class/**/i extends c1,c2,c3{} + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class i/**/extends c1,c2,c3{} + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class i extends/**/c1,c2,c3{} + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class i extends c1/**/,c2,c3{} + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class i extends c1,/**/c2,c3{} + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class i extends c1,c2/**/,c3{} + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class i extends c1,c2,/**/c3{} + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class i extends c1,c2,c3/**/{} + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>/**/class/**/i/**/extends/**/c1,/**/c2,/**/c3/**/{} + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>/**/class/**/i/**/extends/**/c1/**/,/**/c2/**/,/**/c3/**/{} + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>interface KeyValuePair/**/ extends Array { 0: K; 1: V; } + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^^^^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^^^^ + source.ts meta.interface.ts support.class.builtin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts keyword.operator.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface KeyValuePair/**/extends Array { 0: K; 1: V; } + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^^^^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^^^^ + source.ts meta.interface.ts support.class.builtin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts keyword.operator.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface KeyValuePair extends/**/Array { 0: K; 1: V; } + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^^^^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^ + source.ts meta.interface.ts support.class.builtin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts keyword.operator.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface KeyValuePair extends Array/**/ { 0: K; 1: V; } + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^^^^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^^^^ + source.ts meta.interface.ts support.class.builtin.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts keyword.operator.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface KeyValuePair extends Array/**/{ 0: K; 1: V; } + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^^^^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts storage.modifier.ts + ^ + source.ts meta.interface.ts + ^^^^^ + source.ts meta.interface.ts support.class.builtin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts keyword.operator.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> + ^ + source.ts +>interface G/**/ { + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^^^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^^^^^^^^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^^^^^^^ + source.ts meta.interface.ts meta.type.parameters.ts storage.modifier.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^^^^^^^^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> f(x: V): V; + ^^^^ + source.ts meta.interface.ts meta.method.declaration.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts + ^^^^^^^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts storage.modifier.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface G { + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^^^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^^^^^^^^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^^ + source.ts meta.interface.ts meta.type.parameters.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts meta.type.parameters.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^ + source.ts meta.interface.ts meta.type.parameters.ts storage.modifier.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^^^^^^^^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> f(x: V): V; + ^^^^ + source.ts meta.interface.ts meta.method.declaration.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts + ^^^^^^^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts storage.modifier.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface G { + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^^^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^^^^^^^^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts + ^^^^^^^ + source.ts meta.interface.ts meta.type.parameters.ts storage.modifier.ts + ^^ + source.ts meta.interface.ts meta.type.parameters.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.interface.ts meta.type.parameters.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^ + source.ts meta.interface.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> f(x: V): V; + ^^^^ + source.ts meta.interface.ts meta.method.declaration.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts + ^^^^^^^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts storage.modifier.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> + ^ + source.ts +>var x/*comments*/=new String(); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>var x=/*comments*/new String(); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^ + source.ts meta.var.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>var x= new/*comments*/String(); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^^ + source.ts meta.var.expr.ts new.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts new.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>var x /* comments */ = new String(); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>var x = /* comments */ new String(); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>var x = new /* comments */ String(); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^ + source.ts meta.var.expr.ts new.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts new.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Comments.txt b/tests/baselines/Comments.txt deleted file mode 100644 index 0fff0acf..00000000 --- a/tests/baselines/Comments.txt +++ /dev/null @@ -1,77 +0,0 @@ -[9, 5]: source.ts meta.var.expr.ts comment.block.ts -[10, 7]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts -[11, 8]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts -[12, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts -[13, 17]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts -[14, 25]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts -[15, 26]: source.ts comment.block.ts -[17, 5]: source.ts meta.var.expr.ts comment.block.ts -[18, 7]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts -[19, 8]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts -[20, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts comment.block.ts -[21, 17]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts -[22, 25]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts -[24, 1]: source.ts comment.block.ts -[25, 11]: source.ts meta.declaration.object.ts comment.block.ts -[26, 13]: source.ts meta.declaration.object.ts comment.block.ts -[27, 21]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[28, 24]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[29, 25]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[30, 28]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[31, 29]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[32, 32]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[33, 1]: source.ts comment.block.ts -[33, 16]: source.ts meta.declaration.object.ts comment.block.ts -[33, 23]: source.ts meta.declaration.object.ts comment.block.ts -[33, 36]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[33, 45]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[33, 54]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[33, 62]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[34, 1]: source.ts comment.block.ts -[34, 16]: source.ts meta.declaration.object.ts comment.block.ts -[34, 23]: source.ts meta.declaration.object.ts comment.block.ts -[34, 36]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[34, 44]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[34, 51]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[34, 59]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[34, 66]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[34, 74]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[36, 1]: source.ts comment.block.ts -[37, 6]: source.ts meta.declaration.object.ts comment.block.ts -[38, 8]: source.ts meta.declaration.object.ts comment.block.ts -[39, 16]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[40, 19]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[41, 20]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[42, 22]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[43, 23]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[44, 25]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[45, 1]: source.ts comment.block.ts -[45, 10]: source.ts meta.declaration.object.ts comment.block.ts -[45, 15]: source.ts meta.declaration.object.ts comment.block.ts -[45, 26]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[45, 33]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[45, 40]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[45, 46]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[46, 1]: source.ts comment.block.ts -[46, 10]: source.ts meta.declaration.object.ts comment.block.ts -[46, 15]: source.ts meta.declaration.object.ts comment.block.ts -[46, 26]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[46, 32]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[46, 37]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[46, 43]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[46, 48]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[46, 54]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[48, 23]: source.ts meta.declaration.object.ts comment.block.ts -[49, 29]: source.ts meta.declaration.object.ts comment.block.ts -[50, 37]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[51, 43]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[52, 50]: source.ts meta.declaration.object.ts meta.object.heritage.ts comment.block.ts -[54, 12]: source.ts meta.declaration.object.ts comment.block.ts -[57, 31]: source.ts meta.declaration.object.ts meta.type.parameters.ts comment.block.ts -[60, 39]: source.ts meta.declaration.object.ts meta.type.parameters.ts comment.block.ts -[64, 6]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts -[65, 7]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts -[66, 11]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts new.expr.ts comment.block.ts -[68, 7]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts -[69, 9]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts -[70, 13]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts new.expr.ts comment.block.ts \ No newline at end of file diff --git a/tests/baselines/FunctionMethodOverloads.baseline.txt b/tests/baselines/FunctionMethodOverloads.baseline.txt new file mode 100644 index 00000000..d7ba1114 --- /dev/null +++ b/tests/baselines/FunctionMethodOverloads.baseline.txt @@ -0,0 +1,1182 @@ +original file +----------------------------------- +/* Function overload tests */ +export function testFunctionOverload(p: number): new() => any +export function testFunctionOverload(p: string) +export function testFunctionOverload(p: string []) +export function testFunctionOverload(p: {}) +export function testFunctionOverload(p: {a: A, b:B} | string []) +export function testFunctionOverload(p: any): new() => any { + throw new Error("") +} + +export function testFunctionOverloadWithSemicolon(p: number): new () => any; +export function testFunctionOverloadWithSemicolon(p: string); +export function testFunctionOverloadWithSemicolon(p: string[]); +export function testFunctionOverloadWithSemicolon(p: {}); +export function testFunctionOverloadWithSemicolon(p: { a: A, b: B } | string[]); +export function testFunctionOverloadWithSemicolon(p: any): new () => any { + throw new Error("") +} + + +class testClass { + /* Function overload tests */ + public testMethodOverload(p: number): new() => any + public testMethodOverload(p: string) + public testMethodOverload(p: string []) + public testMethodOverload(p: {}) + public testMethodOverload(p: {a: A, b:B} | string []) + public testMethodOverload(p: any): new() => any { + throw new Error("") + } + + public testMethodOverloadWithSemicolon(p: number): new () => any; + public testMethodOverloadWithSemicolon(p: string); + public testMethodOverloadWithSemicolon(p: string[]); + public testMethodOverloadWithSemicolon(p: {}); + public testMethodOverloadWithSemicolon(p: { a: A, b: B } | string[]); + public testMethodOverloadWithSemicolon(p: any): new () => any { + throw new Error("") + } +} + +interface I { + foo(): number + bar(): string; +} + +abstract class C { + abstract foo() + abstract bar() +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/* Function overload tests */ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +>export function testFunctionOverload(p: number): new() => any + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts keyword.control.new.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts support.type.primitive.ts +>export function testFunctionOverload(p: string) + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>export function testFunctionOverload(p: string []) + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>export function testFunctionOverload(p: {}) + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>export function testFunctionOverload(p: {a: A, b:B} | string []) + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>export function testFunctionOverload(p: any): new() => any { + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts keyword.control.new.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> throw new Error("") + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>export function testFunctionOverloadWithSemicolon(p: number): new () => any; + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts keyword.control.new.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts punctuation.terminator.statement.ts +>export function testFunctionOverloadWithSemicolon(p: string); + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>export function testFunctionOverloadWithSemicolon(p: string[]); + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>export function testFunctionOverloadWithSemicolon(p: {}); + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>export function testFunctionOverloadWithSemicolon(p: { a: A, b: B } | string[]); + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>export function testFunctionOverloadWithSemicolon(p: any): new () => any { + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts keyword.control.new.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> throw new Error("") + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +> + ^ + source.ts +>class testClass { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> /* Function overload tests */ + ^^^^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts comment.block.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts +> public testMethodOverload(p: number): new() => any + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts keyword.control.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts support.type.primitive.ts +> public testMethodOverload(p: string) + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts +> public testMethodOverload(p: string []) + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts +> public testMethodOverload(p: {}) + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts +> public testMethodOverload(p: {a: A, b:B} | string []) + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts +> public testMethodOverload(p: any): new() => any { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts keyword.control.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> throw new Error("") + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> public testMethodOverloadWithSemicolon(p: number): new () => any; + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts keyword.control.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public testMethodOverloadWithSemicolon(p: string); + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public testMethodOverloadWithSemicolon(p: string[]); + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public testMethodOverloadWithSemicolon(p: {}); + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public testMethodOverloadWithSemicolon(p: { a: A, b: B } | string[]); + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public testMethodOverloadWithSemicolon(p: any): new () => any { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts keyword.control.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> throw new Error("") + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>interface I { + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> foo(): number + ^^^^ + source.ts meta.interface.ts meta.method.declaration.ts + ^^^ + source.ts meta.interface.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts +> bar(): string; + ^^^^ + source.ts meta.interface.ts meta.method.declaration.ts + ^^^ + source.ts meta.interface.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> + ^ + source.ts +>abstract class C { + ^^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> abstract foo() + ^^^^ + source.ts meta.class.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts +> abstract bar() + ^^^^ + source.ts meta.class.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/FunctionMethodOverloads.txt b/tests/baselines/FunctionMethodOverloads.txt deleted file mode 100644 index e734f9de..00000000 --- a/tests/baselines/FunctionMethodOverloads.txt +++ /dev/null @@ -1,58 +0,0 @@ -[2, 1]: source.ts meta.function.ts storage.type.ts -[2, 17]: source.ts meta.function.ts entity.name.function.ts -[3, 1]: source.ts meta.function.ts meta.function.overload.ts storage.type.ts -[3, 17]: source.ts meta.function.ts meta.function.overload.ts entity.name.function.ts -[4, 1]: source.ts meta.function.ts meta.function.overload.ts storage.type.ts -[4, 17]: source.ts meta.function.ts meta.function.overload.ts entity.name.function.ts -[5, 1]: source.ts meta.function.ts meta.function.overload.ts storage.type.ts -[5, 17]: source.ts meta.function.ts meta.function.overload.ts entity.name.function.ts -[6, 1]: source.ts meta.function.ts meta.function.overload.ts storage.type.ts -[6, 17]: source.ts meta.function.ts meta.function.overload.ts entity.name.function.ts -[7, 1]: source.ts meta.function.ts meta.function.overload.ts storage.type.ts -[7, 17]: source.ts meta.function.ts meta.function.overload.ts entity.name.function.ts -[8, 5]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[11, 1]: source.ts meta.function.ts storage.type.ts -[11, 17]: source.ts meta.function.ts entity.name.function.ts -[12, 1]: source.ts meta.function.ts storage.type.ts -[12, 17]: source.ts meta.function.ts entity.name.function.ts -[13, 1]: source.ts meta.function.ts storage.type.ts -[13, 17]: source.ts meta.function.ts entity.name.function.ts -[14, 1]: source.ts meta.function.ts storage.type.ts -[14, 17]: source.ts meta.function.ts entity.name.function.ts -[15, 1]: source.ts meta.function.ts storage.type.ts -[15, 17]: source.ts meta.function.ts entity.name.function.ts -[16, 1]: source.ts meta.function.ts storage.type.ts -[16, 17]: source.ts meta.function.ts entity.name.function.ts -[17, 5]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[23, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[23, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[24, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.method.overload.declaration.ts storage.modifier.ts -[24, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.method.overload.declaration.ts entity.name.function.ts -[25, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.method.overload.declaration.ts storage.modifier.ts -[25, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.method.overload.declaration.ts entity.name.function.ts -[26, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.method.overload.declaration.ts storage.modifier.ts -[26, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.method.overload.declaration.ts entity.name.function.ts -[27, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.method.overload.declaration.ts storage.modifier.ts -[27, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.method.overload.declaration.ts entity.name.function.ts -[28, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.method.overload.declaration.ts storage.modifier.ts -[28, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.method.overload.declaration.ts entity.name.function.ts -[29, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[32, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[32, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[33, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[33, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[34, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[34, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[35, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[35, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[36, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[36, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[37, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[37, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[38, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[43, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[44, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.method.overload.declaration.ts entity.name.function.ts -[48, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[48, 14]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[49, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.method.overload.declaration.ts storage.modifier.ts -[49, 14]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.method.overload.declaration.ts entity.name.function.ts \ No newline at end of file diff --git a/tests/baselines/FunctionMethodParameters.baseline.txt b/tests/baselines/FunctionMethodParameters.baseline.txt new file mode 100644 index 00000000..b67d6814 --- /dev/null +++ b/tests/baselines/FunctionMethodParameters.baseline.txt @@ -0,0 +1,740 @@ +original file +----------------------------------- +/* Function parameter tests */ +function testFunctionParamType( + m1: string, + m2: {}, + m3: any [], + m4: {a: A, b: B}, + m5: () => void, + m6: (x:(string), y:[number, string]) => number, + m7: Array, + m8: [number, number], + m9: {a: A, b: B} | [number, number], + m10: (() => void) | string[]): number { + return m6.length; +} + +class testClass { + /* method param type tests */ + public testMethodParamType( + m1: string, + m2: {}, + m3: any [], + m4: {a: A, b: B}, + m5: () => void, + m6: (x:(string), y:[number, string]) => number, + m7: Array, + m8: [number, number], + m9: {a: A, b: B} | [number, number], + m10: (() => void) | string[]): number { + return m6.length; + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/* Function parameter tests */ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +>function testFunctionParamType( + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts +> m1: string, + ^^^^ + source.ts meta.function.ts meta.parameters.ts + ^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^^ + source.ts meta.function.ts meta.parameters.ts +> m2: {}, + ^^^^ + source.ts meta.function.ts meta.parameters.ts + ^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts +> m3: any [], + ^^^^ + source.ts meta.function.ts meta.parameters.ts + ^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts +> m4: {a: A, b: B}, + ^^^^ + source.ts meta.function.ts meta.parameters.ts + ^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts +> m5: () => void, + ^^^^ + source.ts meta.function.ts meta.parameters.ts + ^^ + source.ts meta.function.ts meta.parameters.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.return.ts + ^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts +> m6: (x:(string), y:[number, string]) => number, + ^^^^ + source.ts meta.function.ts meta.parameters.ts + ^^ + source.ts meta.function.ts meta.parameters.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts +> m7: Array, + ^^^^ + source.ts meta.function.ts meta.parameters.ts + ^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts +> m8: [number, number], + ^^^^ + source.ts meta.function.ts meta.parameters.ts + ^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts +> m9: {a: A, b: B} | [number, number], + ^^^^ + source.ts meta.function.ts meta.parameters.ts + ^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^^ + source.ts meta.function.ts meta.parameters.ts +> m10: (() => void) | string[]): number { + ^^^^ + source.ts meta.function.ts meta.parameters.ts + ^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts + ^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.return.ts + ^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> return m6.length; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts support.variable.property.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>class testClass { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> /* method param type tests */ + ^^^^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts comment.block.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts +> public testMethodParamType( + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts +> m1: string, + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts +> m2: {}, + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts +> m3: any [], + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts +> m4: {a: A, b: B}, + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts +> m5: () => void, + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.return.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts +> m6: (x:(string), y:[number, string]) => number, + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts +> m7: Array, + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts +> m8: [number, number], + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts +> m9: {a: A, b: B} | [number, number], + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts +> m10: (() => void) | string[]): number { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.return.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> return m6.length; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts support.variable.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/FunctionMethodParameters.txt b/tests/baselines/FunctionMethodParameters.txt deleted file mode 100644 index 4e009180..00000000 --- a/tests/baselines/FunctionMethodParameters.txt +++ /dev/null @@ -1,22 +0,0 @@ -[3, 5]: source.ts meta.function.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[4, 5]: source.ts meta.function.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[5, 5]: source.ts meta.function.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[6, 5]: source.ts meta.function.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[7, 5]: source.ts meta.function.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[8, 5]: source.ts meta.function.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[9, 5]: source.ts meta.function.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[10, 5]: source.ts meta.function.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[11, 5]: source.ts meta.function.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[12, 5]: source.ts meta.function.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[13, 5]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[19, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[20, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[21, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[22, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[23, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[24, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[25, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[26, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[27, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[28, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[29, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts diff --git a/tests/baselines/FunctionMethodReturnTypes.baseline.txt b/tests/baselines/FunctionMethodReturnTypes.baseline.txt new file mode 100644 index 00000000..0fecebf8 --- /dev/null +++ b/tests/baselines/FunctionMethodReturnTypes.baseline.txt @@ -0,0 +1,1814 @@ +original file +----------------------------------- +/* Function return type tests */ +export function testFunctionReturnType1(): string [] { return [""] } +export function testFunctionReturnType2(): {} { return {} } +export function testFunctionReturnType3(): {a: A, b: B} { return {a: {m: "" }, b: {m1: "" }} } +export function testFunctionReturnType4(): [number, number] { return [1, 1] } +export function testFunctionReturnType5(): Array { return [{ m: "" }] } +export function testFunctionReturnType6(): new () => number { throw new Error(""); } +export function testFunctionReturnType7(): (() => number) { throw new Error(""); } +export function testFunctionReturnType8(): (() => number) [] { throw new Error(""); } +export function testFunctionReturnType9(): (() => number) | (() => string) { throw new Error(""); } +export function testFunctionReturnType10(): {a: A, b: B} [] { return [{a: {m: "" }, b: {m1: "" }}] } +export function testFunctionReturnType11(): number | string { return 1 } +export function testFunctionReturnType12(): number | string [] { return } +export function testFunctionReturnType13(): [number, number] | string [] { return [""] } + +class TestClass { + /* method return type tests */ + public testMethodReturnType1(): string [] { return [""] } + public testMethodReturnType2(): {} { return {} } + public testMethodReturnType3(): {a: A, b: B} { return {a: {m: "" }, b: {m1: "" }} } + public testMethodReturnType4(): [number, number] { return [1, 1] } + public testMethodReturnType5(): Array { return [{ m: "" }] } + public testMethodReturnType6(): new () => number { throw new Error(""); } + public testMethodReturnType7(): (() => number) { throw new Error(""); } + public testMethodReturnType8(): (() => number) [] { throw new Error(""); } + public testMethodReturnType9(): (() => number) | (() => string) { throw new Error(""); } + public testMethodReturnType10(): {a: A, b: B} [] { return [{a: {m: "" }, b: {m1: "" }}] } + public testMethodReturnType11(): number | string { return 1 } + public testMethodReturnType12(): number | string [] { return } + public testMethodReturnType13(): [number, number] | string [] { return [""] } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/* Function return type tests */ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +>export function testFunctionReturnType1(): string [] { return [""] } + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>export function testFunctionReturnType2(): {} { return {} } + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>export function testFunctionReturnType3(): {a: A, b: B} { return {a: {m: "" }, b: {m1: "" }} } + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>export function testFunctionReturnType4(): [number, number] { return [1, 1] } + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>export function testFunctionReturnType5(): Array { return [{ m: "" }] } + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^^ + source.ts meta.function.ts meta.return.type.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>export function testFunctionReturnType6(): new () => number { throw new Error(""); } + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts keyword.control.new.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>export function testFunctionReturnType7(): (() => number) { throw new Error(""); } + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>export function testFunctionReturnType8(): (() => number) [] { throw new Error(""); } + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>export function testFunctionReturnType9(): (() => number) | (() => string) { throw new Error(""); } + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>export function testFunctionReturnType10(): {a: A, b: B} [] { return [{a: {m: "" }, b: {m1: "" }}] } + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>export function testFunctionReturnType11(): number | string { return 1 } + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>export function testFunctionReturnType12(): number | string [] { return } + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>export function testFunctionReturnType13(): [number, number] | string [] { return [""] } + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>class TestClass { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> /* method return type tests */ + ^^^^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts comment.block.ts + ^^ + source.ts meta.class.ts comment.block.ts punctuation.definition.comment.ts +> public testMethodReturnType1(): string [] { return [""] } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> public testMethodReturnType2(): {} { return {} } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> public testMethodReturnType3(): {a: A, b: B} { return {a: {m: "" }, b: {m1: "" }} } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> public testMethodReturnType4(): [number, number] { return [1, 1] } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> public testMethodReturnType5(): Array { return [{ m: "" }] } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> public testMethodReturnType6(): new () => number { throw new Error(""); } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts keyword.control.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.function.return.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> public testMethodReturnType7(): (() => number) { throw new Error(""); } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> public testMethodReturnType8(): (() => number) [] { throw new Error(""); } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> public testMethodReturnType9(): (() => number) | (() => string) { throw new Error(""); } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.paren.cover.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> public testMethodReturnType10(): {a: A, b: B} [] { return [{a: {m: "" }, b: {m1: "" }}] } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> public testMethodReturnType11(): number | string { return 1 } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> public testMethodReturnType12(): number | string [] { return } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> public testMethodReturnType13(): [number, number] | string [] { return [""] } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/FunctionMethodReturnTypes.txt b/tests/baselines/FunctionMethodReturnTypes.txt deleted file mode 100644 index 6b35d12b..00000000 --- a/tests/baselines/FunctionMethodReturnTypes.txt +++ /dev/null @@ -1,78 +0,0 @@ -[2, 1]: source.ts meta.function.ts storage.type.ts -[2, 17]: source.ts meta.function.ts entity.name.function.ts -[2, 56]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[3, 1]: source.ts meta.function.ts storage.type.ts -[3, 17]: source.ts meta.function.ts entity.name.function.ts -[3, 49]: source.ts meta.block.ts keyword.control.ts -[4, 1]: source.ts meta.function.ts storage.type.ts -[4, 17]: source.ts meta.function.ts entity.name.function.ts -[4, 59]: source.ts meta.block.ts keyword.control.ts -[5, 1]: source.ts meta.function.ts storage.type.ts -[5, 17]: source.ts meta.function.ts entity.name.function.ts -[5, 63]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[6, 1]: source.ts meta.function.ts storage.type.ts -[6, 17]: source.ts meta.function.ts entity.name.function.ts -[6, 55]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[7, 1]: source.ts meta.function.ts storage.type.ts -[7, 17]: source.ts meta.function.ts entity.name.function.ts -[7, 63]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[8, 1]: source.ts meta.function.ts storage.type.ts -[8, 17]: source.ts meta.function.ts entity.name.function.ts -[8, 61]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[9, 1]: source.ts meta.function.ts storage.type.ts -[9, 17]: source.ts meta.function.ts entity.name.function.ts -[9, 64]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[10, 1]: source.ts meta.function.ts storage.type.ts -[10, 17]: source.ts meta.function.ts entity.name.function.ts -[10, 78]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[11, 1]: source.ts meta.function.ts storage.type.ts -[11, 17]: source.ts meta.function.ts entity.name.function.ts -[11, 63]: source.ts meta.block.ts keyword.control.ts -[12, 1]: source.ts meta.function.ts storage.type.ts -[12, 17]: source.ts meta.function.ts entity.name.function.ts -[12, 63]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[13, 1]: source.ts meta.function.ts storage.type.ts -[13, 17]: source.ts meta.function.ts entity.name.function.ts -[13, 66]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[14, 1]: source.ts meta.function.ts storage.type.ts -[14, 17]: source.ts meta.function.ts entity.name.function.ts -[14, 76]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[18, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[18, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[18, 49]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[19, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[19, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[19, 42]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[20, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[20, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[20, 52]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[21, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[21, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[21, 56]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[22, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[22, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[22, 48]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[23, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[23, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[23, 56]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[24, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[24, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[24, 54]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[25, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[25, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[25, 57]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[26, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[26, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[26, 71]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[27, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[27, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[27, 56]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[28, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[28, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[28, 56]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[29, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[29, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[29, 59]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts -[30, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.modifier.ts -[30, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[30, 69]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.control.ts \ No newline at end of file diff --git a/tests/baselines/Issue10.baseline.txt b/tests/baselines/Issue10.baseline.txt new file mode 100644 index 00000000..434f6f57 --- /dev/null +++ b/tests/baselines/Issue10.baseline.txt @@ -0,0 +1,192 @@ +original file +----------------------------------- +enum Hello { + A, + B +} + +class World { + normal() { + let x = 5; + console.log("hello"); + } + + [Hello.A]() { + let x = 5; + console.log("hello"); + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>enum Hello { + ^^^^ + source.ts meta.enum.declaration.ts storage.type.enum.ts + ^ + source.ts meta.enum.declaration.ts + ^^^^^ + source.ts meta.enum.declaration.ts entity.name.type.enum.ts + ^ + source.ts meta.enum.declaration.ts + ^ + source.ts meta.enum.declaration.ts punctuation.definition.block.ts +> A, + ^^^^ + source.ts meta.enum.declaration.ts + ^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> B + ^^^^ + source.ts meta.enum.declaration.ts + ^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts +>} + ^ + source.ts meta.enum.declaration.ts punctuation.definition.block.ts +> + ^ + source.ts +>class World { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> normal() { + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> let x = 5; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> console.log("hello"); + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> [Hello.A]() { + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts punctuation.accessor.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> let x = 5; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> console.log("hello"); + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue1006.baseline.txt b/tests/baselines/Issue1006.baseline.txt new file mode 100644 index 00000000..1ca57dfc --- /dev/null +++ b/tests/baselines/Issue1006.baseline.txt @@ -0,0 +1,36 @@ +original file +----------------------------------- +const a = /.*/v; + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const a = /.*/v; + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts string.regexp.ts + ^ + source.ts meta.var.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts string.regexp.ts constant.other.character-class.regexp + ^ + source.ts meta.var.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.var.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts string.regexp.ts keyword.other.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue11.baseline.txt b/tests/baselines/Issue11.baseline.txt new file mode 100644 index 00000000..a9e0d12a --- /dev/null +++ b/tests/baselines/Issue11.baseline.txt @@ -0,0 +1,94 @@ +original file +----------------------------------- +for (var i=0; i<10; i++) { + var x = 1; + var p = ""; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>for (var i=0; i<10; i++) { + ^^^ + source.ts keyword.control.loop.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts keyword.operator.relational.ts + ^^ + source.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^^ + source.ts keyword.operator.increment.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> var x = 1; + ^^^^ + source.ts meta.block.ts + ^^^ + source.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts +> var p = ""; + ^^^^ + source.ts meta.block.ts + ^^^ + source.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue110.baseline.txt b/tests/baselines/Issue110.baseline.txt new file mode 100644 index 00000000..f0d16135 --- /dev/null +++ b/tests/baselines/Issue110.baseline.txt @@ -0,0 +1,348 @@ +original file +----------------------------------- +let number1 = 0x100 +let number2 = 14e15 +let number3 = 10.42e41.5 +let number4 = 4 +let number5 = 51.4 +let number6 = 12.4E10.2 +let number7 = 14.6e+10 +let number8 = 12E4 +let number9 = 10e10 +let number10 = 14e14.5 +let number11 = 12E-10 +let number12 = 13.4e-14.2 +let number13 = 14.12 +let number14 = 10.2E+4 +let number6 = 5.00567789e+2 +let i = 1, j = 1e3 + +/* + + Testing comments +*/ +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let number1 = 0x100 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts constant.numeric.hex.ts + ^^^ + source.ts meta.var.expr.ts +>let number2 = 14e15 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>let number3 = 10.42e41.5 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts punctuation.accessor.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts +>let number4 = 4 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>let number5 = 51.4 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>let number6 = 12.4E10.2 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts punctuation.accessor.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>let number7 = 14.6e+10 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>let number8 = 12E4 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>let number9 = 10e10 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>let number10 = 14e14.5 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts punctuation.accessor.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>let number11 = 12E-10 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>let number12 = 13.4e-14.2 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts punctuation.accessor.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>let number13 = 14.12 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>let number14 = 10.2E+4 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>let number6 = 5.00567789e+2 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>let i = 1, j = 1e3 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +> + ^ + source.ts +>/* + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +> + ^ + source.ts comment.block.ts +> Testing comments + ^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts +>*/ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts \ No newline at end of file diff --git a/tests/baselines/Issue110.txt b/tests/baselines/Issue110.txt deleted file mode 100644 index 4702f7be..00000000 --- a/tests/baselines/Issue110.txt +++ /dev/null @@ -1,18 +0,0 @@ -[1, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[2, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[3, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[4, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[5, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[6, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[7, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[8, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[9, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[10, 16]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[11, 16]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[12, 16]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[13, 16]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[14, 16]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[15, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[16, 9]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[16, 16]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[19, 1]: source.ts comment.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue112.baseline.txt b/tests/baselines/Issue112.baseline.txt new file mode 100644 index 00000000..4b9cef66 --- /dev/null +++ b/tests/baselines/Issue112.baseline.txt @@ -0,0 +1,108 @@ +original file +----------------------------------- +return new vscode.Variable(property.name, displayValue, variablesReference); +angular.module('app') +this._connections.delete(connection.id); +this._waitingConnections.delete(connection); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>return new vscode.Variable(property.name, displayValue, variablesReference); + ^^^^^^ + source.ts keyword.control.flow.ts + ^ + source.ts + ^^^ + source.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts new.expr.ts + ^^^^^^ + source.ts new.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts new.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts new.expr.ts meta.brace.round.ts + ^^^^^^^^ + source.ts new.expr.ts variable.other.object.ts + ^ + source.ts new.expr.ts punctuation.accessor.ts + ^^^^ + source.ts new.expr.ts support.variable.property.dom.ts + ^ + source.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts new.expr.ts + ^^^^^^^^^^^^ + source.ts new.expr.ts variable.other.readwrite.ts + ^ + source.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts new.expr.ts + ^^^^^^^^^^^^^^^^^^ + source.ts new.expr.ts variable.other.readwrite.ts + ^ + source.ts new.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>angular.module('app') + ^^^^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts string.quoted.single.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.brace.round.ts +>this._connections.delete(connection.id); + ^^^^ + source.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^ + source.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^^^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^ + source.ts support.variable.property.dom.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>this._waitingConnections.delete(connection); + ^^^^ + source.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue114.baseline.txt b/tests/baselines/Issue114.baseline.txt new file mode 100644 index 00000000..5877a399 --- /dev/null +++ b/tests/baselines/Issue114.baseline.txt @@ -0,0 +1,148 @@ +original file +----------------------------------- +export type BreakpointType = 'line' | 'call' | 'return' | 'exception' | 'conditional' | 'watch' +interface Test { + type: 'line' | 'call' | 'return'; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export type BreakpointType = 'line' | 'call' | 'return' | 'exception' | 'conditional' | 'watch' + ^^^^^^ + source.ts meta.type.declaration.ts keyword.control.export.ts + ^ + source.ts meta.type.declaration.ts + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^^^^^^^^^^^^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts +>interface Test { + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> type: 'line' | 'call' | 'return'; + ^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue115.baseline.txt b/tests/baselines/Issue115.baseline.txt new file mode 100644 index 00000000..0f69573c --- /dev/null +++ b/tests/baselines/Issue115.baseline.txt @@ -0,0 +1,308 @@ +original file +----------------------------------- +class Foo { + bar(a: Foo, b: string) { } +} + +function foo(a: Foo, b: string) { } + +const bar = function (a: Foo, b: string) { } + +const baz = (a: Foo, b: string) => { }; + +const qux = { + bar(a: Foo, b: string) { }, + set bar2(x: string) { } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Foo { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> bar(a: Foo, b: string) { } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>function foo(a: Foo, b: string) { } + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>const bar = function (a: Foo, b: string) { } + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>const baz = (a: Foo, b: string) => { }; + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>const qux = { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> bar(a: Foo, b: string) { }, + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> set bar2(x: string) { } + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts storage.type.property.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue119.baseline.txt b/tests/baselines/Issue119.baseline.txt new file mode 100644 index 00000000..8b03d62d --- /dev/null +++ b/tests/baselines/Issue119.baseline.txt @@ -0,0 +1,104 @@ +original file +----------------------------------- +class x { + public SomeMethod() { + } + public OtherMethod() { } + + public SomeMethod = () => { } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class x { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> public SomeMethod() { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> public OtherMethod() { } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> public SomeMethod = () => { } + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue124.baseline.txt b/tests/baselines/Issue124.baseline.txt new file mode 100644 index 00000000..a6b11b03 --- /dev/null +++ b/tests/baselines/Issue124.baseline.txt @@ -0,0 +1,288 @@ +original file +----------------------------------- +/* + Solving Issue #124, #80, #81 + Adding capability of ternary strings. +*/ + +let a = true ? true : true; +let b = true ? true : `this is ${} highlighted` +let c = true ? `hello` : `this ${DEPENDENCY_SEPARATOR}${moduleName} is highlighted`; + +var newVar = a ? (b == `hello`) : true; + +var debArch = arch === 'x64' ? 'amd64' : 'i386'; + +/* + Comment +*/ +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/* + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +> Solving Issue #124, #80, #81 + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts +> Adding capability of ternary strings. + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts +>*/ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +> + ^ + source.ts +>let a = true ? true : true; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.language.boolean.true.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.language.boolean.true.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.language.boolean.true.ts + ^ + source.ts punctuation.terminator.statement.ts + ^^^ + source.ts +>let b = true ? true : `this is ${} highlighted` + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.language.boolean.true.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.language.boolean.true.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^^^^^^^ + source.ts meta.var.expr.ts string.template.ts + ^^ + source.ts meta.var.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^ + source.ts meta.var.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.template.ts + ^ + source.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.end.ts +>let c = true ? `hello` : `this ${DEPENDENCY_SEPARATOR}${moduleName} is highlighted`; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.language.boolean.true.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.template.ts + ^ + source.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.template.ts + ^^ + source.ts meta.var.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^ + source.ts meta.var.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.template.ts + ^ + source.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>var newVar = a ? (b == `hello`) : true; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts keyword.operator.comparison.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.template.ts + ^ + source.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.language.boolean.true.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>var debArch = arch === 'x64' ? 'amd64' : 'i386'; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts keyword.operator.comparison.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>/* + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +> Comment + ^^^^^^^^^ + source.ts comment.block.ts +>*/ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts \ No newline at end of file diff --git a/tests/baselines/Issue124.txt b/tests/baselines/Issue124.txt deleted file mode 100644 index e01630c5..00000000 --- a/tests/baselines/Issue124.txt +++ /dev/null @@ -1,27 +0,0 @@ -[6, 9]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.language.boolean.ts -[6, 16]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.language.boolean.ts -[6, 23]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.language.boolean.ts -[7, 9]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.language.boolean.ts -[7, 16]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.language.boolean.ts -[7, 23]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.template.ts string.template.ts -[7, 24]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.template.ts string.template.ts -[7, 32]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.template.ts template.element.ts keyword.others.ts -[8, 9]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.language.boolean.ts -[8, 16]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.template.ts string.template.ts -[8, 17]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.template.ts string.template.ts -[8, 26]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.template.ts string.template.ts -[8, 27]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.template.ts string.template.ts -[10, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts variable.ts -[10, 14]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts -[10, 16]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts -[10, 18]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.brace.paren.ts -[10, 35]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.language.boolean.ts -[12, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts variable.ts -[12, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts -[12, 20]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts keyword.operator.comparison.ts -[12, 24]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[12, 30]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts -[12, 32]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[12, 40]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts -[12, 42]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[15, 2]: source.ts comment.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue131.baseline.txt b/tests/baselines/Issue131.baseline.txt new file mode 100644 index 00000000..c89f59e0 --- /dev/null +++ b/tests/baselines/Issue131.baseline.txt @@ -0,0 +1,46 @@ +original file +----------------------------------- +foo.namespace +foo.any +var number, string; +number +string +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>foo.namespace + ^^^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts variable.other.property.ts +>foo.any + ^^^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^^ + source.ts variable.other.property.ts +>var number, string; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +>number + ^^^^^^ + source.ts variable.other.readwrite.ts +>string + ^^^^^^ + source.ts variable.other.readwrite.ts \ No newline at end of file diff --git a/tests/baselines/Issue133.baseline.txt b/tests/baselines/Issue133.baseline.txt new file mode 100644 index 00000000..403ccff3 --- /dev/null +++ b/tests/baselines/Issue133.baseline.txt @@ -0,0 +1,60 @@ +original file +----------------------------------- +interface I { + $fieldName: string; + $getFieldViewCtrl: () => FieldView; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>interface I { + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> $fieldName: string; + ^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +> $getFieldViewCtrl: () => FieldView; + ^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts entity.name.function.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.return.ts + ^^^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.return.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue135.baseline.txt b/tests/baselines/Issue135.baseline.txt new file mode 100644 index 00000000..7b34111e --- /dev/null +++ b/tests/baselines/Issue135.baseline.txt @@ -0,0 +1,34 @@ +original file +----------------------------------- +import http = require('http'); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>import http = require('http'); + ^^^^^^ + source.ts meta.import-equals.external.ts keyword.control.import.ts + ^ + source.ts meta.import-equals.external.ts + ^^^^ + source.ts meta.import-equals.external.ts variable.other.readwrite.alias.ts + ^ + source.ts meta.import-equals.external.ts + ^ + source.ts meta.import-equals.external.ts keyword.operator.assignment.ts + ^ + source.ts meta.import-equals.external.ts + ^^^^^^^ + source.ts meta.import-equals.external.ts keyword.control.require.ts + ^ + source.ts meta.import-equals.external.ts meta.brace.round.ts + ^ + source.ts meta.import-equals.external.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.import-equals.external.ts string.quoted.single.ts + ^ + source.ts meta.import-equals.external.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.import-equals.external.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue139.baseline.txt b/tests/baselines/Issue139.baseline.txt new file mode 100644 index 00000000..99558ba0 --- /dev/null +++ b/tests/baselines/Issue139.baseline.txt @@ -0,0 +1,76 @@ +original file +----------------------------------- +new new Proxy(function fn() { + console.log(this.constructor.name); +}, {}); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>new new Proxy(function fn() { + ^^^ + source.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts new.expr.ts + ^^^ + source.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts new.expr.ts + ^^^^^ + source.ts new.expr.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts new.expr.ts meta.brace.round.ts + ^^^^^^^^ + source.ts new.expr.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts new.expr.ts meta.function.expression.ts + ^^ + source.ts new.expr.ts meta.function.expression.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts new.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts new.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts new.expr.ts meta.function.expression.ts + ^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> console.log(this.constructor.name); + ^^^^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts + ^^^^^^^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts variable.language.this.ts + ^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts support.variable.property.ts + ^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +>}, {}); + ^ + source.ts new.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts new.expr.ts + ^ + source.ts new.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts new.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts new.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue142.baseline.txt b/tests/baselines/Issue142.baseline.txt new file mode 100644 index 00000000..f3ba7e26 --- /dev/null +++ b/tests/baselines/Issue142.baseline.txt @@ -0,0 +1,106 @@ +original file +----------------------------------- +class x { + abc = () => + this.func(this.arr.concat(['one 1', 'two 2', 'three 3'])); +} + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class x { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> abc = () => + ^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts storage.type.function.arrow.ts +> this.func(this.arr.concat(['one 1', 'two 2', 'three 3'])); + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue143.baseline.txt b/tests/baselines/Issue143.baseline.txt new file mode 100644 index 00000000..e66fd071 --- /dev/null +++ b/tests/baselines/Issue143.baseline.txt @@ -0,0 +1,328 @@ +original file +----------------------------------- +import {Component, HostListener, Directive} from 'angular2/core'; + +@Directive({selector: 'button[counting]'}) +class CountClicks { + numberOfClicks = 0; + @HostListener('click', ['$event.target']) onClick(btn) { + console.log("button", btn, "number of clicks:", this.numberOfClicks++); + } +} +@Component({ + selector: 'my-app', + template: ``, + directives: [CountClicks] +}) +export class AppComponent { + constructor() { console.clear(); } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>import {Component, HostListener, Directive} from 'angular2/core'; + ^^^^^^ + source.ts meta.import.ts keyword.control.import.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts meta.block.ts punctuation.definition.block.ts + ^^^^^^^^^ + source.ts meta.import.ts meta.block.ts variable.other.readwrite.alias.ts + ^ + source.ts meta.import.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.import.ts meta.block.ts + ^^^^^^^^^^^^ + source.ts meta.import.ts meta.block.ts variable.other.readwrite.alias.ts + ^ + source.ts meta.import.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.import.ts meta.block.ts + ^^^^^^^^^ + source.ts meta.import.ts meta.block.ts variable.other.readwrite.alias.ts + ^ + source.ts meta.import.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.import.ts + ^^^^ + source.ts meta.import.ts keyword.control.from.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^ + source.ts meta.import.ts string.quoted.single.ts + ^ + source.ts meta.import.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>@Directive({selector: 'button[counting]'}) + ^ + source.ts meta.decorator.ts punctuation.decorator.ts + ^^^^^^^^^ + source.ts meta.decorator.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.decorator.ts meta.brace.round.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts punctuation.definition.block.ts + ^^^^^^^^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.decorator.ts meta.brace.round.ts +>class CountClicks { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> numberOfClicks = 0; + ^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> @HostListener('click', ['$event.target']) onClick(btn) { + ^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.decorator.ts punctuation.decorator.ts + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.decorator.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.decorator.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.class.ts meta.decorator.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.decorator.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.decorator.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^ + source.ts meta.class.ts meta.decorator.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> console.log("button", btn, "number of clicks:", this.numberOfClicks++); + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.property.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.increment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>@Component({ + ^ + source.ts meta.decorator.ts punctuation.decorator.ts + ^^^^^^^^^ + source.ts meta.decorator.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.decorator.ts meta.brace.round.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts punctuation.definition.block.ts +> selector: 'my-app', + ^^ + source.ts meta.decorator.ts meta.objectliteral.ts + ^^^^^^^^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts punctuation.separator.comma.ts +> template: ``, + ^^ + source.ts meta.decorator.ts meta.objectliteral.ts + ^^^^^^^^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts string.template.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts punctuation.separator.comma.ts +> directives: [CountClicks] + ^^ + source.ts meta.decorator.ts meta.objectliteral.ts + ^^^^^^^^^^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts meta.brace.square.ts + ^^^^^^^^^^^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.decorator.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts meta.brace.square.ts +>}) + ^ + source.ts meta.decorator.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.decorator.ts meta.brace.round.ts +>export class AppComponent { + ^^^^^^ + source.ts meta.class.ts keyword.control.export.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> constructor() { console.clear(); } + ^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue146.baseline.txt b/tests/baselines/Issue146.baseline.txt new file mode 100644 index 00000000..e2744664 --- /dev/null +++ b/tests/baselines/Issue146.baseline.txt @@ -0,0 +1,106 @@ +original file +----------------------------------- +function foo() { + return 'bar'; +} + +function* foo() { + yield 'bar'; + yield* ['bar']; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function foo() { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> return 'bar'; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.function.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>function* foo() { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts keyword.generator.asterisk.ts + ^ + source.ts meta.function.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> yield 'bar'; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.function.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +> yield* ['bar']; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.generator.asterisk.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue148.baseline.txt b/tests/baselines/Issue148.baseline.txt new file mode 100644 index 00000000..a59cc92d --- /dev/null +++ b/tests/baselines/Issue148.baseline.txt @@ -0,0 +1,148 @@ +original file +----------------------------------- +class Test { + constructor( + @inject private test: string, + @inject("test") private test2: string, + @inject("test") test3: string, + public test4: string + ) { } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Test { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> constructor( + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts +> @inject private test: string, + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts punctuation.decorator.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts +> @inject("test") private test2: string, + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts punctuation.decorator.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts +> @inject("test") test3: string, + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts punctuation.decorator.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.decorator.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts +> public test4: string + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts +> ) { } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue149.baseline.txt b/tests/baselines/Issue149.baseline.txt new file mode 100644 index 00000000..48674e2a --- /dev/null +++ b/tests/baselines/Issue149.baseline.txt @@ -0,0 +1,290 @@ +original file +----------------------------------- +export function fn(s: string): new() => View +export function fn(s: string) +export function fn(n: number) +export function fn(s: any) { + return ""; +} + +export function fn(s: string): new () => View; +export function fn(s: string); +export function fn(n: number); +export function fn(s: any) { + return ""; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export function fn(s: string): new() => View + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts keyword.control.new.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts entity.name.type.ts +>export function fn(s: string) + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>export function fn(n: number) + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>export function fn(s: any) { + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> return ""; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>export function fn(s: string): new () => View; + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts keyword.control.new.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.constructor.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts entity.name.type.ts + ^ + source.ts punctuation.terminator.statement.ts +>export function fn(s: string); + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>export function fn(n: number); + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>export function fn(s: any) { + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> return ""; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue149.txt b/tests/baselines/Issue149.txt deleted file mode 100644 index 0db9e5a0..00000000 --- a/tests/baselines/Issue149.txt +++ /dev/null @@ -1,23 +0,0 @@ -[1, 1]: source.ts meta.function.ts storage.type.ts -[1, 17]: source.ts meta.function.ts entity.name.function.ts -[1, 23]: source.ts meta.function.ts meta.function.type.parameter.ts meta.type.annotation.ts meta.type.primitive.ts support.type.ts -[1, 32]: source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts keyword.control.ts -[1, 41]: source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts meta.type.name.ts -[2, 1]: source.ts meta.function.ts meta.function.overload.ts storage.type.ts -[2, 17]: source.ts meta.function.ts meta.function.overload.ts entity.name.function.ts -[3, 1]: source.ts meta.function.ts meta.function.overload.ts storage.type.ts -[3, 17]: source.ts meta.function.ts meta.function.overload.ts entity.name.function.ts -[4, 1]: source.ts meta.function.ts meta.function.overload.ts storage.type.ts -[4, 17]: source.ts meta.function.ts meta.function.overload.ts entity.name.function.ts -[5, 5]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts -[8, 1]: source.ts meta.function.ts storage.type.ts -[8, 17]: source.ts meta.function.ts entity.name.function.ts -[8, 32]: source.ts meta.function.ts meta.return.type.ts meta.type.paren.cover.ts keyword.control.ts -[8, 42]: source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts meta.type.name.ts -[9, 1]: source.ts meta.function.ts storage.type.ts -[9, 17]: source.ts meta.function.ts entity.name.function.ts -[10, 1]: source.ts meta.function.ts storage.type.ts -[10, 17]: source.ts meta.function.ts entity.name.function.ts -[11, 1]: source.ts meta.function.ts storage.type.ts -[11, 17]: source.ts meta.function.ts entity.name.function.ts -[12, 5]: source.ts meta.function.ts meta.decl.block.ts keyword.control.ts \ No newline at end of file diff --git a/tests/baselines/Issue152.baseline.txt b/tests/baselines/Issue152.baseline.txt new file mode 100644 index 00000000..485bc177 --- /dev/null +++ b/tests/baselines/Issue152.baseline.txt @@ -0,0 +1,152 @@ +original file +----------------------------------- +var node; +for(var i; i< 45;i++) { + node = 234; + + node.a = 122; + node.b += 122; + node.b += '1'+1+'2'; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>var node; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +>for(var i; i< 45;i++) { + ^^^ + source.ts keyword.control.loop.ts + ^ + source.ts meta.brace.round.ts + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts keyword.operator.relational.ts + ^ + source.ts + ^^ + source.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts variable.other.readwrite.ts + ^^ + source.ts keyword.operator.increment.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> node = 234; + ^^^^ + source.ts meta.block.ts + ^^^^ + source.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts + ^^^ + source.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.block.ts +> node.a = 122; + ^^^^ + source.ts meta.block.ts + ^^^^ + source.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.block.ts punctuation.accessor.ts + ^ + source.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts + ^^^ + source.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts +> node.b += 122; + ^^^^ + source.ts meta.block.ts + ^^^^ + source.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.block.ts punctuation.accessor.ts + ^ + source.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.block.ts + ^^ + source.ts meta.block.ts keyword.operator.assignment.compound.ts + ^ + source.ts meta.block.ts + ^^^ + source.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts +> node.b += '1'+1+'2'; + ^^^^ + source.ts meta.block.ts + ^^^^ + source.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.block.ts punctuation.accessor.ts + ^ + source.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.block.ts + ^^ + source.ts meta.block.ts keyword.operator.assignment.compound.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue153.baseline.txt b/tests/baselines/Issue153.baseline.txt new file mode 100644 index 00000000..7c09bb30 --- /dev/null +++ b/tests/baselines/Issue153.baseline.txt @@ -0,0 +1,1074 @@ +original file +----------------------------------- +import {Vector3, Vector} from 'vectors'; + +/** + * A simple 3x3 matrix structure. + * + * @export + * @class Matrix3x3 + */ +class Matrix { + public M11 : number; + public M12 : number; + public M13 : number; + public M21 : number; + public M22 : number; + public M23 : number; + public M31 : number; + public M32 : number; + public M33 : number; + + + /** + * Gets a column as a new vector. + * + * @param {number} index The index of the column (0 .. 2). + * @returns {Vector3} A vector representing the column. + */ + public getColumn_Breaks(index : number) : Vector3 { + if (index == 0) { + return new Vector3(this.M11, this.M21, this.M31); + } else if (index == 1) { + return new Vector3(this.M12, this.M22, this.M32); + } else if (index == 2) { + return new Vector3(this.M13, this.M23, this.M33); + } else { + throw new RangeError('Invalid matrix 3x3 column index: ' + index); + } + } + + /** + * Gets a column as a new vector. + * + * @param {number} index The index of the column (0 .. 2). + * @returns {Vector3} A vector representing the column. + */ + public getColumn_Works(index : number) : Vector { + if (index == 0) { + return new Vector(this.M11, this.M21, this.M31); + } else if (index == 1) { + return new Vector(this.M12, this.M22, this.M32); + } else if (index == 2) { + return new Vector(this.M13, this.M23, this.M33); + } else { + throw new RangeError('Invalid matrix 3x3 column index: ' + index); + } + } + +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>import {Vector3, Vector} from 'vectors'; + ^^^^^^ + source.ts meta.import.ts keyword.control.import.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts meta.block.ts punctuation.definition.block.ts + ^^^^^^^ + source.ts meta.import.ts meta.block.ts variable.other.readwrite.alias.ts + ^ + source.ts meta.import.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.import.ts meta.block.ts + ^^^^^^ + source.ts meta.import.ts meta.block.ts variable.other.readwrite.alias.ts + ^ + source.ts meta.import.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.import.ts + ^^^^ + source.ts meta.import.ts keyword.control.from.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.import.ts string.quoted.single.ts + ^ + source.ts meta.import.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>/** + ^^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +> * A simple 3x3 matrix structure. + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> * + ^^^^ + source.ts comment.block.documentation.ts +> * @export + ^^^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc +> * @class Matrix3x3 + ^^^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc + ^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> */ + ^ + source.ts comment.block.documentation.ts + ^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +>class Matrix { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> public M11 : number; + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public M12 : number; + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public M13 : number; + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public M21 : number; + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public M22 : number; + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public M23 : number; + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public M31 : number; + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public M32 : number; + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public M33 : number; + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.class.ts +> + ^ + source.ts meta.class.ts +> /** + ^^^^ + source.ts meta.class.ts + ^^^ + source.ts meta.class.ts comment.block.documentation.ts punctuation.definition.comment.ts +> * Gets a column as a new vector. + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts +> * + ^^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts +> * @param {number} index The index of the column (0 .. 2). + ^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts + ^ + source.ts meta.class.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^ + source.ts meta.class.ts comment.block.documentation.ts storage.type.class.jsdoc + ^ + source.ts meta.class.ts comment.block.documentation.ts + ^ + source.ts meta.class.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.begin.jsdoc + ^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts meta.class.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.end.jsdoc + ^ + source.ts meta.class.ts comment.block.documentation.ts + ^^^^^ + source.ts meta.class.ts comment.block.documentation.ts variable.other.jsdoc + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts +> * @returns {Vector3} A vector representing the column. + ^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts + ^ + source.ts meta.class.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts storage.type.class.jsdoc + ^ + source.ts meta.class.ts comment.block.documentation.ts + ^ + source.ts meta.class.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.begin.jsdoc + ^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts meta.class.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.end.jsdoc + ^ + source.ts meta.class.ts comment.block.documentation.ts + ^ + source.ts meta.class.ts comment.block.documentation.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts +> */ + ^^^^^ + source.ts meta.class.ts comment.block.documentation.ts + ^^ + source.ts meta.class.ts comment.block.documentation.ts punctuation.definition.comment.ts +> public getColumn_Breaks(index : number) : Vector3 { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> if (index == 0) { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> return new Vector3(this.M11, this.M21, this.M31); + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } else if (index == 1) { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> return new Vector3(this.M12, this.M22, this.M32); + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } else if (index == 2) { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> return new Vector3(this.M13, this.M23, this.M33); + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } else { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> throw new RangeError('Invalid matrix 3x3 column index: ' + index); + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> /** + ^^^^ + source.ts meta.class.ts + ^^^ + source.ts meta.class.ts comment.block.documentation.ts punctuation.definition.comment.ts +> * Gets a column as a new vector. + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts +> * + ^^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts +> * @param {number} index The index of the column (0 .. 2). + ^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts + ^ + source.ts meta.class.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^ + source.ts meta.class.ts comment.block.documentation.ts storage.type.class.jsdoc + ^ + source.ts meta.class.ts comment.block.documentation.ts + ^ + source.ts meta.class.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.begin.jsdoc + ^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts meta.class.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.end.jsdoc + ^ + source.ts meta.class.ts comment.block.documentation.ts + ^^^^^ + source.ts meta.class.ts comment.block.documentation.ts variable.other.jsdoc + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts +> * @returns {Vector3} A vector representing the column. + ^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts + ^ + source.ts meta.class.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts storage.type.class.jsdoc + ^ + source.ts meta.class.ts comment.block.documentation.ts + ^ + source.ts meta.class.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.begin.jsdoc + ^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts meta.class.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.end.jsdoc + ^ + source.ts meta.class.ts comment.block.documentation.ts + ^ + source.ts meta.class.ts comment.block.documentation.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts +> */ + ^^^^^ + source.ts meta.class.ts comment.block.documentation.ts + ^^ + source.ts meta.class.ts comment.block.documentation.ts punctuation.definition.comment.ts +> public getColumn_Works(index : number) : Vector { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> if (index == 0) { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> return new Vector(this.M11, this.M21, this.M31); + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } else if (index == 1) { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> return new Vector(this.M12, this.M22, this.M32); + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } else if (index == 2) { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> return new Vector(this.M13, this.M23, this.M33); + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } else { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> throw new RangeError('Invalid matrix 3x3 column index: ' + index); + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.error.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue154.baseline.txt b/tests/baselines/Issue154.baseline.txt new file mode 100644 index 00000000..7de81ee6 --- /dev/null +++ b/tests/baselines/Issue154.baseline.txt @@ -0,0 +1,134 @@ +original file +----------------------------------- +class TestCase { + ['foo']() { + this.registerComponent('foo-bar'); + } +} + +class TestCase2 { + foo() { + this.registerComponent('foo-bar'); + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class TestCase { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> ['foo']() { + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> this.registerComponent('foo-bar'); + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>class TestCase2 { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> foo() { + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> this.registerComponent('foo-bar'); + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue155.baseline.txt b/tests/baselines/Issue155.baseline.txt new file mode 100644 index 00000000..433879b6 --- /dev/null +++ b/tests/baselines/Issue155.baseline.txt @@ -0,0 +1,322 @@ +original file +----------------------------------- +matchQuery.find().then(function (results) { + for (i=0;imatchQuery.find().then(function (results) { + ^^^^^^^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function-call.ts support.function.promise.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^ + source.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.function.expression.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.expression.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> for (i=0;i notificationQuery.find().then(function (notifications){ + ^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.promise.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> var j; + ^^^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> for (j=0;j console.log('safeDeleteRoute notification result'+j); + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> notifications[j].destroy(); + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> res.destroy(); + ^^^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> }); + ^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> },function(error){ + ^^^^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts punctuation.separator.comma.ts + ^^^^^^^^ + source.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> alert("Error: "+error.code + " " + error.message); + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.function.expression.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.expression.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.function.expression.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> }); + ^^^^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue156.baseline.txt b/tests/baselines/Issue156.baseline.txt new file mode 100644 index 00000000..79053cf0 --- /dev/null +++ b/tests/baselines/Issue156.baseline.txt @@ -0,0 +1,80 @@ +original file +----------------------------------- +class Test { + mmm(p1: string | {}, p2: string) + { + + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Test { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> mmm(p1: string | {}, p2: string) + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts +> { + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +> + ^^^^^^^^^ + source.ts meta.class.ts meta.block.ts +> } + ^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue156.txt b/tests/baselines/Issue156.txt deleted file mode 100644 index 18e1180b..00000000 --- a/tests/baselines/Issue156.txt +++ /dev/null @@ -1,7 +0,0 @@ -[2, 2]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[2, 6]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[2, 10]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts meta.type.annotation.ts meta.type.primitive.ts support.type.ts -[2, 19]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts meta.type.annotation.ts meta.object.type.ts meta.brace.curly.ts -[2, 23]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[2, 27]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts meta.type.annotation.ts meta.type.primitive.ts support.type.ts -[4, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue157.baseline.txt b/tests/baselines/Issue157.baseline.txt new file mode 100644 index 00000000..d7a3d1c0 --- /dev/null +++ b/tests/baselines/Issue157.baseline.txt @@ -0,0 +1,82 @@ +original file +----------------------------------- +const items = new Set([ 'foo', 'bar' ]); +items.delete('foo'); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const items = new Set([ 'foo', 'bar' ]); + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.array.literal.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.array.literal.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.array.literal.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>items.delete('foo'); + ^^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts string.quoted.single.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue158.baseline.txt b/tests/baselines/Issue158.baseline.txt new file mode 100644 index 00000000..54d369bf --- /dev/null +++ b/tests/baselines/Issue158.baseline.txt @@ -0,0 +1,132 @@ +original file +----------------------------------- +class Test +{ + public constructor() + { + for (let it=0; it<10; it++) + { + } + } + + private doSomething() + { + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Test + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^ + source.ts meta.class.ts entity.name.type.class.ts +>{ + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> public constructor() + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts +> { + ^^^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +> for (let it=0; it<10; it++) + ^^^^^^^^ + source.ts meta.class.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.block.ts keyword.control.loop.ts + ^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.class.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.block.ts meta.var.expr.ts + ^^ + source.ts meta.class.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.class.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.block.ts keyword.operator.relational.ts + ^^ + source.ts meta.class.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.class.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.block.ts variable.other.readwrite.ts + ^^ + source.ts meta.class.ts meta.block.ts keyword.operator.increment.ts + ^ + source.ts meta.class.ts meta.block.ts meta.brace.round.ts +> { + ^^^^^^^^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^^^^^ + source.ts meta.class.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^^ + source.ts meta.class.ts meta.block.ts +> } + ^^^^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> private doSomething() + ^^^^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts +> { + ^^^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue161.baseline.txt b/tests/baselines/Issue161.baseline.txt new file mode 100644 index 00000000..405876f9 --- /dev/null +++ b/tests/baselines/Issue161.baseline.txt @@ -0,0 +1,116 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has jsx +let root: React.ReactElement<{}>; +let page: PageName; +if (isViaPage) { + root = ; + page = 'via'; +} +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has jsx + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx comment.line.double-slash.tsx +>let root: React.ReactElement<{}>; + ^^^ + source.tsx meta.var.expr.tsx storage.type.tsx + ^ + source.tsx meta.var.expr.tsx + ^^^^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.definition.variable.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.type.annotation.tsx + ^^^^^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.type.annotation.tsx entity.name.type.module.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.type.annotation.tsx punctuation.accessor.tsx + ^^^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.type.annotation.tsx entity.name.type.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.type.annotation.tsx meta.type.parameters.tsx meta.object.type.tsx punctuation.definition.block.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.type.annotation.tsx meta.type.parameters.tsx meta.object.type.tsx punctuation.definition.block.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +>let page: PageName; + ^^^ + source.tsx meta.var.expr.tsx storage.type.tsx + ^ + source.tsx meta.var.expr.tsx + ^^^^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.definition.variable.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.type.annotation.tsx + ^^^^^^^^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.type.annotation.tsx entity.name.type.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +>if (isViaPage) { + ^^ + source.tsx keyword.control.conditional.tsx + ^ + source.tsx + ^ + source.tsx meta.brace.round.tsx + ^^^^^^^^^ + source.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx + ^ + source.tsx meta.block.tsx punctuation.definition.block.tsx +> root = ; + ^^ + source.tsx meta.block.tsx + ^^^^ + source.tsx meta.block.tsx support.variable.object.node.tsx + ^ + source.tsx meta.block.tsx + ^ + source.tsx meta.block.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.block.tsx + ^ + source.tsx meta.block.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^^^^^^^ + source.tsx meta.block.tsx meta.tag.tsx entity.name.tag.tsx support.class.component.tsx + ^^ + source.tsx meta.block.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.block.tsx punctuation.terminator.statement.tsx +> page = 'via'; + ^^ + source.tsx meta.block.tsx + ^^^^ + source.tsx meta.block.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.block.tsx + ^ + source.tsx meta.block.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.block.tsx + ^ + source.tsx meta.block.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^^^ + source.tsx meta.block.tsx string.quoted.single.tsx + ^ + source.tsx meta.block.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.block.tsx punctuation.terminator.statement.tsx +>} + ^ + source.tsx meta.block.tsx punctuation.definition.block.tsx \ No newline at end of file diff --git a/tests/baselines/Issue163.baseline.txt b/tests/baselines/Issue163.baseline.txt new file mode 100644 index 00000000..db4634a6 --- /dev/null +++ b/tests/baselines/Issue163.baseline.txt @@ -0,0 +1,56 @@ +original file +----------------------------------- +const o = { + async f() { + + } +}; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const o = { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> async f() { + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts storage.modifier.async.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts +> } + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>}; + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue166.baseline.txt b/tests/baselines/Issue166.baseline.txt new file mode 100644 index 00000000..278f9c89 --- /dev/null +++ b/tests/baselines/Issue166.baseline.txt @@ -0,0 +1,288 @@ +original file +----------------------------------- +type x = string | "aaa" | "bbb" | "ccc" | number; +type x1 = string | + "aaa" | + "bbb" | "ccc" | number; +type x2 = string | /*comment*/ "aaa" | "bbb" | "ccc" | number; /*comment*/ +type x3 = string | "aaa" | //comment + "bbb" | "ccc" | number; //comment +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>type x = string | "aaa" | "bbb" | "ccc" | number; + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^^^^^^ + source.ts meta.type.declaration.ts support.type.primitive.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.type.declaration.ts string.quoted.double.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.type.declaration.ts string.quoted.double.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.type.declaration.ts string.quoted.double.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^^^^^^ + source.ts meta.type.declaration.ts support.type.primitive.ts + ^ + source.ts punctuation.terminator.statement.ts +>type x1 = string | + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^^^^^^ + source.ts meta.type.declaration.ts support.type.primitive.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts +> "aaa" | + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.type.declaration.ts string.quoted.double.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts +> "bbb" | "ccc" | number; + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.type.declaration.ts string.quoted.double.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.type.declaration.ts string.quoted.double.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^^^^^^ + source.ts meta.type.declaration.ts support.type.primitive.ts + ^ + source.ts punctuation.terminator.statement.ts +>type x2 = string | /*comment*/ "aaa" | "bbb" | "ccc" | number; /*comment*/ + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^^^^^^ + source.ts meta.type.declaration.ts support.type.primitive.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^ + source.ts meta.type.declaration.ts comment.block.ts + ^^ + source.ts meta.type.declaration.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.type.declaration.ts string.quoted.double.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.type.declaration.ts string.quoted.double.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.type.declaration.ts string.quoted.double.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^^^^^^ + source.ts meta.type.declaration.ts support.type.primitive.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +>type x3 = string | "aaa" | //comment + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^^^^^^ + source.ts meta.type.declaration.ts support.type.primitive.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.type.declaration.ts string.quoted.double.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^ + source.ts meta.type.declaration.ts comment.line.double-slash.ts +> "bbb" | "ccc" | number; //comment + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.type.declaration.ts string.quoted.double.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.type.declaration.ts string.quoted.double.ts + ^ + source.ts meta.type.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^^^^^^ + source.ts meta.type.declaration.ts support.type.primitive.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^ + source.ts comment.line.double-slash.ts \ No newline at end of file diff --git a/tests/baselines/Issue171.baseline.txt b/tests/baselines/Issue171.baseline.txt new file mode 100644 index 00000000..424593d7 --- /dev/null +++ b/tests/baselines/Issue171.baseline.txt @@ -0,0 +1,306 @@ +original file +----------------------------------- +class c { + constructor + ( + private parameters: { + stringContent: string; + minLength: number; + maxLength: number, + validationErrorMessage: string + }) { + + } + private x: number = Date.now() // TODO: momentjs? + private link_visits_counter: number = 0; +} + +function foo() { + new c + ({ + stringContent: "something", + minLength: 1, + maxLength: 5, + validationErrorMessage: "something else" + }); +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class c { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> constructor + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts +> ( + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts +> private parameters: { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts +> stringContent: string; + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.terminator.statement.ts +> minLength: number; + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.terminator.statement.ts +> maxLength: number, + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.separator.comma.ts +> validationErrorMessage: string + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts +> }) { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> private x: number = Date.now() // TODO: momentjs? + ^^^^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts comment.line.double-slash.ts +> private link_visits_counter: number = 0; + ^^^^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>function foo() { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> new c + ^^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts variable.other.readwrite.ts +> ({ + ^^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts +> stringContent: "something", + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts + ^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.separator.comma.ts +> minLength: 1, + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts + ^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.separator.comma.ts +> maxLength: 5, + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts + ^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.separator.comma.ts +> validationErrorMessage: "something else" + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts +> }); + ^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue172.baseline.txt b/tests/baselines/Issue172.baseline.txt new file mode 100644 index 00000000..a4e10aef --- /dev/null +++ b/tests/baselines/Issue172.baseline.txt @@ -0,0 +1,76 @@ +original file +----------------------------------- +let f = async (x) => {}; +let f2 = async function(x) {}; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let f = async (x) => {}; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.modifier.async.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts +>let f2 = async function(x) {}; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts storage.modifier.async.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue175.baseline.txt b/tests/baselines/Issue175.baseline.txt new file mode 100644 index 00000000..277eed83 --- /dev/null +++ b/tests/baselines/Issue175.baseline.txt @@ -0,0 +1,50 @@ +original file +----------------------------------- +var $ = ''; +var $foo = ''; + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>var $ = ''; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>var $foo = ''; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue177.baseline.txt b/tests/baselines/Issue177.baseline.txt new file mode 100644 index 00000000..18e91c98 --- /dev/null +++ b/tests/baselines/Issue177.baseline.txt @@ -0,0 +1,50 @@ +original file +----------------------------------- +() => (/s/); +() => /s/; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>() => (/s/); + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts string.regexp.ts + ^ + source.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>() => /s/; + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts string.regexp.ts + ^ + source.ts meta.arrow.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.arrow.ts string.regexp.ts + ^ + source.ts meta.arrow.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue178.baseline.txt b/tests/baselines/Issue178.baseline.txt new file mode 100644 index 00000000..fd1761b0 --- /dev/null +++ b/tests/baselines/Issue178.baseline.txt @@ -0,0 +1,196 @@ +original file +----------------------------------- +const a: { [key: string]: () => string } = null; +const b: { [key: string]: [string, () => string] } = null; +const c = "foobar"; +const d = 5; +const e: any = null; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const a: { [key: string]: () => string } = null; + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.function.return.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.language.null.ts + ^ + source.ts punctuation.terminator.statement.ts +>const b: { [key: string]: [string, () => string] } = null; + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.tuple.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.tuple.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.tuple.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.tuple.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.tuple.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.tuple.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.tuple.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.tuple.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.language.null.ts + ^ + source.ts punctuation.terminator.statement.ts +>const c = "foobar"; + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>const d = 5; + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +>const e: any = null; + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.language.null.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue180.baseline.txt b/tests/baselines/Issue180.baseline.txt new file mode 100644 index 00000000..61a8d6bf --- /dev/null +++ b/tests/baselines/Issue180.baseline.txt @@ -0,0 +1,314 @@ +original file +----------------------------------- +if (typeof oSettings.aanFeatures.f != 'undefined') +{ + var n = oSettings.aanFeatures.f; + for ( i=0, iLen=n.length ; iif (typeof oSettings.aanFeatures.f != 'undefined') + ^^ + source.ts keyword.control.conditional.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^ + source.ts keyword.operator.expression.typeof.ts + ^ + source.ts + ^^^^^^^^^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts variable.other.object.property.ts + ^ + source.ts punctuation.accessor.ts + ^ + source.ts variable.other.property.ts + ^ + source.ts + ^^ + source.ts keyword.operator.comparison.ts + ^ + source.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^ + source.ts string.quoted.single.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.brace.round.ts +>{ + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> var n = oSettings.aanFeatures.f; + ^^^^ + source.ts meta.block.ts + ^^^ + source.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.block.ts meta.var.expr.ts variable.other.object.property.ts + ^ + source.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^ + source.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts +> for ( i=0, iLen=n.length ; i { + ^^^^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> $('input', n[i]).val( '' ); + ^^^^^^^^ + source.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.block.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.block.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts meta.block.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.block.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>/* some comment + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^ + source.ts comment.block.ts +> * + ^^^ + source.ts comment.block.ts +> */ + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +>for ( i=0, iLen=oSettings.aoPreSearchCols.length ; i{ + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> oSetttings.something = ""; + ^^^^ + source.ts meta.block.ts + ^^^^^^^^^^ + source.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>/* redraw */ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts \ No newline at end of file diff --git a/tests/baselines/Issue182.baseline.txt b/tests/baselines/Issue182.baseline.txt new file mode 100644 index 00000000..2a09b911 --- /dev/null +++ b/tests/baselines/Issue182.baseline.txt @@ -0,0 +1,70 @@ +original file +----------------------------------- +if (this.PListCells.lengthif (this.PListCells.length{ + ^ + source.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue183.baseline.txt b/tests/baselines/Issue183.baseline.txt new file mode 100644 index 00000000..45e87b8a --- /dev/null +++ b/tests/baselines/Issue183.baseline.txt @@ -0,0 +1,218 @@ +original file +----------------------------------- +class Sample2 +{ + constructor() + { + } + + callback = (): void => + { + } + + public method1(): void + { + } + private method2 () : number + { + return 2; + } + method3 () : string + { + return "method3"; + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Sample2 + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts +>{ + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> constructor() + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts +> { + ^^^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> callback = (): void => + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.return.type.arrow.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.return.type.arrow.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.return.type.arrow.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts storage.type.function.arrow.ts +> { + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> public method1(): void + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts +> { + ^^^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +> private method2 () : number + ^^^^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts +> { + ^^^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +> return 2; + ^^^^^^^^ + source.ts meta.class.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +> method3 () : string + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts +> { + ^^^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +> return "method3"; + ^^^^^^^^ + source.ts meta.class.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.class.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue186.baseline.txt b/tests/baselines/Issue186.baseline.txt new file mode 100644 index 00000000..8423fc53 --- /dev/null +++ b/tests/baselines/Issue186.baseline.txt @@ -0,0 +1,222 @@ +original file +----------------------------------- +function myFunction(param1, param2, number, string, boolean) { + let y = (number) => { + console.log(param1); + } + console.log(param1); + console.log(param1 + number); + console.log(string); + console.log(boolean); + let x = param1 ? 2 : param2; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function myFunction(param1, param2, number, string, boolean) { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^^^^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> let y = (number) => { + ^^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> console.log(param1); + ^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> console.log(param1); + ^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +> console.log(param1 + number); + ^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +> console.log(string); + ^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +> console.log(boolean); + ^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +> let x = param1 ? 2 : param2; + ^^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue187.baseline.txt b/tests/baselines/Issue187.baseline.txt new file mode 100644 index 00000000..a91298f7 --- /dev/null +++ b/tests/baselines/Issue187.baseline.txt @@ -0,0 +1,142 @@ +original file +----------------------------------- +const trim = module.exports = str => trim.trailing(trim.leading(str)); + +const trim = module.exports = function(str) { + return trim.trailing(trim.leading(str)); +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const trim = module.exports = str => trim.trailing(trim.leading(str)); + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts support.type.object.module.ts + ^ + source.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.var.expr.ts support.type.object.module.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^^^^ + source.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^^^^ + source.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^^^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>const trim = module.exports = function(str) { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts support.type.object.module.ts + ^ + source.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.var.expr.ts support.type.object.module.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> return trim.trailing(trim.leading(str)); + ^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts keyword.control.flow.ts + ^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts + ^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue191.baseline.txt b/tests/baselines/Issue191.baseline.txt new file mode 100644 index 00000000..c39eedbd --- /dev/null +++ b/tests/baselines/Issue191.baseline.txt @@ -0,0 +1,430 @@ +original file +----------------------------------- +class Thing { + constructor(public content: string){ + var prop = Q.defer(); + this.store = new Data(); + gaze(path.join(this.content, "**/*.json"), (err, watch) => { + process.stuout.write(`Watching for changes in:`); + }) + }; +} + +class Thing { + constructor(public content: string){ + var prop = Q.defer(); + this.store = new Data(); + gaze(path.join(this.content, "**/*.json"), (err, watch) => { + process.stuout.write(`Watching for changes in:`); + }) + }; +} + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Thing { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> constructor(public content: string){ + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> var prop = Q.defer(); + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.function-call.ts variable.other.constant.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> this.store = new Data(); + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> gaze(path.join(this.content, "**/*.json"), (err, watch) => { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.parameters.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> process.stuout.write(`Watching for changes in:`); + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts support.variable.object.process.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts string.template.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> }) + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts +> }; + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>class Thing { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> constructor(public content: string){ + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> var prop = Q.defer(); + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.function-call.ts variable.other.constant.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> this.store = new Data(); + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> gaze(path.join(this.content, "**/*.json"), (err, watch) => { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.parameters.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> process.stuout.write(`Watching for changes in:`); + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts support.variable.object.process.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts string.template.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> }) + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts +> }; + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue191.txt b/tests/baselines/Issue191.txt deleted file mode 100644 index 4bc56603..00000000 --- a/tests/baselines/Issue191.txt +++ /dev/null @@ -1,32 +0,0 @@ -[2, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.type.ts -[2, 17]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts storage.modifier.ts -[2, 24]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[2, 33]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts meta.type.annotation.ts meta.type.primitive.ts support.type.ts -[3, 13]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts variable.ts -[3, 28]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts -[3, 37]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.brace.paren.ts -[4, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts constant.language.this.ts -[4, 26]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts new.expr.ts meta.type.name.ts -[5, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts -[5, 39]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts string.double.ts -[5, 49]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.brace.paren.ts -[6, 13]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.block.ts -[6, 35]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.block.ts meta.template.ts string.template.ts -[6, 60]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.block.ts meta.brace.paren.ts -[11, 13]: source.ts meta.declaration.object.ts meta.type.parameters.ts meta.type.name.ts -[11, 16]: source.ts meta.declaration.object.ts meta.type.parameters.ts meta.type.name.ts -[12, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.type.ts -[12, 17]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts storage.modifier.ts -[12, 24]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[12, 33]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts meta.type.annotation.ts meta.type.primitive.ts support.type.ts -[13, 13]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts variable.ts -[13, 28]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts -[13, 37]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.brace.paren.ts -[14, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts constant.language.this.ts -[14, 26]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts new.expr.ts meta.type.name.ts -[15, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts -[15, 39]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts string.double.ts -[15, 49]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.brace.paren.ts -[16, 13]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.block.ts -[16, 35]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.block.ts meta.template.ts string.template.ts -[16, 60]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.block.ts meta.brace.paren.ts \ No newline at end of file diff --git a/tests/baselines/Issue193.baseline.txt b/tests/baselines/Issue193.baseline.txt new file mode 100644 index 00000000..73d1a22f --- /dev/null +++ b/tests/baselines/Issue193.baseline.txt @@ -0,0 +1,116 @@ +original file +----------------------------------- +function Main_Функция(s: string) +{ +} + +function Функция_Main(s: string) +{ +} + +let item = "value1"; +let элемент = "value2"; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function Main_Функция(s: string) + ^ + source.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>{ + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>function Функция_Main(s: string) + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>{ + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>let item = "value1"; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>let элемент = "value2"; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue197.baseline.txt b/tests/baselines/Issue197.baseline.txt new file mode 100644 index 00000000..3584c722 --- /dev/null +++ b/tests/baselines/Issue197.baseline.txt @@ -0,0 +1,322 @@ +original file +----------------------------------- + export class sampleClass { + public equipmentTypeList: string[] = ["FAX", "OFFICE PHONE"]; + public pbxEquipmentType = "FAX"; + public spliceRightStripName = "TE"; + public cablePairStatusValues: any[] = + [ + { statusText: "Assigned" }, + { statusText: "Faulty" }, + { statusText: "Not in Use" }, + ]; + public cablePairStatusValueForAssigned = "Assigned"; + public cablePairStatusValueForFaulty = "Faulty"; + public phoneCircuitType = "Phone"; + } +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +> export class sampleClass { + ^ + source.ts + ^^^^^^ + source.ts meta.class.ts keyword.control.export.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> public equipmentTypeList: string[] = ["FAX", "OFFICE PHONE"]; + ^^^^^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public pbxEquipmentType = "FAX"; + ^^^^^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public spliceRightStripName = "TE"; + ^^^^^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts + ^^ + source.ts meta.class.ts +> public cablePairStatusValues: any[] = + ^^^^^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts +> [ + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts +> { statusText: "Assigned" }, + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts punctuation.separator.comma.ts +> { statusText: "Faulty" }, + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts punctuation.separator.comma.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts +> { statusText: "Not in Use" }, + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts punctuation.separator.comma.ts +> ]; + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public cablePairStatusValueForAssigned = "Assigned"; + ^^^^^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public cablePairStatusValueForFaulty = "Faulty"; + ^^^^^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> public phoneCircuitType = "Phone"; + ^^^^^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> } + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue198.baseline.txt b/tests/baselines/Issue198.baseline.txt new file mode 100644 index 00000000..baf9a7c7 --- /dev/null +++ b/tests/baselines/Issue198.baseline.txt @@ -0,0 +1,238 @@ +original file +----------------------------------- +let a = 0, b = 0, c = 0; +let value = a / b + / c; +let value2 = a / b + / c * a + b / a / b / c; +let value2 = a / b / c * a + b / a / b / c; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let a = 0, b = 0, c = 0; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +>let value = a / b + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts +> / c; + ^^^^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +>let value2 = a / b + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts +> / c * a + b / a / b / c; + ^^^^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +>let value2 = a / b / c * a + b / a / b / c; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue200.baseline.txt b/tests/baselines/Issue200.baseline.txt new file mode 100644 index 00000000..3b74ba11 --- /dev/null +++ b/tests/baselines/Issue200.baseline.txt @@ -0,0 +1,90 @@ +original file +----------------------------------- + + +declare module 'goog:goog.i18n.NumberFormatSymbols_en_TT' { + import alias = lool.clutz.goog.i18n.NumberFormatSymbols_en_TT; + export default alias; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +> + ^ + source.ts +> + ^ + source.ts +>declare module 'goog:goog.i18n.NumberFormatSymbols_en_TT' { + ^^^^^^^ + source.ts meta.namespace.declaration.ts storage.modifier.ts + ^ + source.ts meta.namespace.declaration.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts storage.type.namespace.ts + ^ + source.ts meta.namespace.declaration.ts + ^ + source.ts meta.namespace.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.namespace.declaration.ts string.quoted.single.ts + ^ + source.ts meta.namespace.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.namespace.declaration.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts +> import alias = lool.clutz.goog.i18n.NumberFormatSymbols_en_TT; + ^^ + source.ts meta.namespace.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts keyword.control.import.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts + ^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts variable.other.readwrite.alias.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts keyword.operator.assignment.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts + ^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts entity.name.type.module.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts entity.name.type.module.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts punctuation.accessor.ts + ^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts entity.name.type.module.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts punctuation.accessor.ts + ^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts entity.name.type.module.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.import-equals.internal.ts variable.other.readwrite.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> export default alias; + ^^ + source.ts meta.namespace.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.export.default.ts keyword.control.export.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.export.default.ts + ^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.export.default.ts keyword.control.default.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.export.default.ts + ^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.export.default.ts variable.other.readwrite.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue200.txt b/tests/baselines/Issue200.txt deleted file mode 100644 index ee7a0bac..00000000 --- a/tests/baselines/Issue200.txt +++ /dev/null @@ -1,11 +0,0 @@ -[1, 1]: source.ts -[3, 1]: source.ts keyword.control.ts -[3, 9]: source.ts storage.type.ts -[3, 16]: source.ts string.single.ts -[4, 3]: source.ts meta.block.ts keyword.control.import.include.ts -[4, 10]: source.ts meta.block.ts -[4, 18]: source.ts meta.block.ts -[5, 3]: source.ts meta.block.ts storage.type.ts -[5, 10]: source.ts meta.block.ts keyword.control.ts -[5, 18]: source.ts meta.block.ts -[6, 1]: source.ts meta.block.ts meta.brace.curly.ts \ No newline at end of file diff --git a/tests/baselines/Issue202.baseline.txt b/tests/baselines/Issue202.baseline.txt new file mode 100644 index 00000000..ccb03686 --- /dev/null +++ b/tests/baselines/Issue202.baseline.txt @@ -0,0 +1,102 @@ +original file +----------------------------------- +interface Test { + test: T; +} + +interface Props { + prop: Test; +} + +class Whatever { +} +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>interface Test { + ^^^^^^^^^ + source.tsx meta.interface.tsx storage.type.interface.tsx + ^ + source.tsx meta.interface.tsx + ^^^^ + source.tsx meta.interface.tsx entity.name.type.interface.tsx + ^ + source.tsx meta.interface.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + ^ + source.tsx meta.interface.tsx meta.type.parameters.tsx entity.name.type.tsx + ^ + source.tsx meta.interface.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + ^ + source.tsx meta.interface.tsx + ^ + source.tsx meta.interface.tsx punctuation.definition.block.tsx +> test: T; + ^^^^ + source.tsx meta.interface.tsx meta.field.declaration.tsx + ^^^^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.definition.property.tsx variable.object.property.tsx + ^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx + ^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx entity.name.type.tsx + ^ + source.tsx meta.interface.tsx punctuation.terminator.statement.tsx +>} + ^ + source.tsx meta.interface.tsx punctuation.definition.block.tsx +> + ^ + source.tsx +>interface Props { + ^^^^^^^^^ + source.tsx meta.interface.tsx storage.type.interface.tsx + ^ + source.tsx meta.interface.tsx + ^^^^^ + source.tsx meta.interface.tsx entity.name.type.interface.tsx + ^ + source.tsx meta.interface.tsx + ^ + source.tsx meta.interface.tsx punctuation.definition.block.tsx +> prop: Test; + ^^^^ + source.tsx meta.interface.tsx meta.field.declaration.tsx + ^^^^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.definition.property.tsx variable.object.property.tsx + ^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx + ^^^^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx entity.name.type.tsx + ^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + ^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx meta.type.parameters.tsx entity.name.type.tsx + ^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + ^ + source.tsx meta.interface.tsx punctuation.terminator.statement.tsx +>} + ^ + source.tsx meta.interface.tsx punctuation.definition.block.tsx +> + ^ + source.tsx +>class Whatever { + ^^^^^ + source.tsx meta.class.tsx storage.type.class.tsx + ^ + source.tsx meta.class.tsx + ^^^^^^^^ + source.tsx meta.class.tsx entity.name.type.class.tsx + ^ + source.tsx meta.class.tsx + ^ + source.tsx meta.class.tsx punctuation.definition.block.tsx +>} + ^ + source.tsx meta.class.tsx punctuation.definition.block.tsx \ No newline at end of file diff --git a/tests/baselines/Issue203.baseline.txt b/tests/baselines/Issue203.baseline.txt new file mode 100644 index 00000000..e60a65ea --- /dev/null +++ b/tests/baselines/Issue203.baseline.txt @@ -0,0 +1,152 @@ +original file +----------------------------------- +var [] = 'fafa'.replace('blah'); +console.log('hello'); + +var [] = 'fafa'.replace(''); +console.log('hello'); +while { while() {} } +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>var [] = 'fafa'.replace('blah'); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts + ^ + source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts + ^ + source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>console.log('hello'); + ^^^^^^^ + source.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts string.quoted.single.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>var [] = 'fafa'.replace(''); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts + ^ + source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts + ^ + source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>console.log('hello'); + ^^^^^^^ + source.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts string.quoted.single.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>while { while() {} } + ^^^^^ + source.ts keyword.control.loop.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.block.ts + ^^^^^ + source.ts meta.block.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue206.baseline.txt b/tests/baselines/Issue206.baseline.txt new file mode 100644 index 00000000..f6dfd8dd --- /dev/null +++ b/tests/baselines/Issue206.baseline.txt @@ -0,0 +1,558 @@ +original file +----------------------------------- +interface A {} +interface B {} +interface C {} + +type D = A | B | C +type D1 = A + | B + | C +type D3 = + A + | B + | C +type D2 + = A + | B + | C + +type E = 'e1' | 'e2' | 'e3' +type E1 = 'e1' + | 'e2' + | 'e3' +type E2 = + 'e1' + | 'e2' + | 'e3' +type E3 + = 'e1' + | 'e2' + | 'e3' + +type F = A & B & C +type F1 = A + & B + & C +type F2 = + A + & B + & C +type F3 + = A + & B + & C +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>interface A {} + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface B {} + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>interface C {} + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> + ^ + source.ts +>type D = A | B | C + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +>type D1 = A + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +> | B + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +> | C + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +>type D3 = + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^^ + source.ts meta.type.declaration.ts +> A + ^^^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +> | B + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +> | C + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +>type D2 + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts +> = A + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +> | B + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +> | C + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +> + ^ + source.ts +>type E = 'e1' | 'e2' | 'e3' + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts +>type E1 = 'e1' + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^^ + source.ts meta.type.declaration.ts +> | 'e2' + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^^ + source.ts meta.type.declaration.ts +> | 'e3' + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts +>type E2 = + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^^ + source.ts meta.type.declaration.ts +> 'e1' + ^^^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^^ + source.ts meta.type.declaration.ts +> | 'e2' + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^^ + source.ts meta.type.declaration.ts +> | 'e3' + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts +>type E3 + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^^ + source.ts meta.type.declaration.ts +> = 'e1' + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^^ + source.ts meta.type.declaration.ts +> | 'e2' + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^^ + source.ts meta.type.declaration.ts +> | 'e3' + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.type.declaration.ts string.quoted.single.ts + ^ + source.ts meta.type.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts +> + ^ + source.ts +>type F = A & B & C + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +>type F1 = A + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +> & B + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +> & C + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +>type F2 = + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts +> A + ^^^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +> & B + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +> & C + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +>type F3 + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts +> = A + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +> & B + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts +> & C + ^^^^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.ts \ No newline at end of file diff --git a/tests/baselines/Issue208.baseline.txt b/tests/baselines/Issue208.baseline.txt new file mode 100644 index 00000000..6bda514b --- /dev/null +++ b/tests/baselines/Issue208.baseline.txt @@ -0,0 +1,282 @@ +original file +----------------------------------- +var someVar = new Thing('data'); +var someVar = makeThing('data'); + +class MyClass { + static someProp = new Thing('data'); + static someProp = makeThing('data'); + + someProp = new Thing('data'); + someProp = makeThing('data'); +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>var someVar = new Thing('data'); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.type.parameters.ts + ^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.var.expr.ts new.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>var someVar = makeThing('data'); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>class MyClass { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> static someProp = new Thing('data'); + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts + ^^^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> static someProp = makeThing('data'); + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.class.ts +> someProp = new Thing('data'); + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts + ^^^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> someProp = makeThing('data'); + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue208.txt b/tests/baselines/Issue208.txt deleted file mode 100644 index c5f26c9e..00000000 --- a/tests/baselines/Issue208.txt +++ /dev/null @@ -1,25 +0,0 @@ -[1, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts new.expr.ts keyword.others.ts -[1, 19]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts new.expr.ts meta.type.parameters.ts entity.name.type.ts -[1, 25]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts new.expr.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts -[1, 33]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts new.expr.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts -[1, 42]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[1, 47]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.brace.paren.ts -[2, 15]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.parameters.ts entity.name.type.ts -[2, 25]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts -[2, 33]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts -[2, 42]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[2, 47]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.brace.paren.ts -[5, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts variable.ts -[5, 27]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts entity.name.type.ts -[5, 33]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts -[5, 41]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts -[6, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts variable.ts -[6, 23]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts meta.type.parameters.ts entity.name.type.ts -[6, 33]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts -[6, 41]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts -[8, 20]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts entity.name.type.ts -[8, 26]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts -[8, 34]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts new.expr.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts -[9, 16]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts meta.type.parameters.ts entity.name.type.ts -[9, 26]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts -[9, 34]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts meta.type.parameters.ts meta.type.primitive.ts support.type.ts \ No newline at end of file diff --git a/tests/baselines/Issue212.baseline.txt b/tests/baselines/Issue212.baseline.txt new file mode 100644 index 00000000..d87ac86e --- /dev/null +++ b/tests/baselines/Issue212.baseline.txt @@ -0,0 +1,188 @@ +original file +----------------------------------- +let from = neki; +from = a; // is a variable and should be in white color like other variables + +exports.myVar = async (ctx, next) => {} // this is all in white but exports and async should be e.g. in red or blue + +t.me = 1; +t.is = 2; // `is` is in blue but should be the same color as the above (1) +t.in = 3; // `in` is in blue but should be the same color as the above (1) +t.of = 4; // `of` is in blue but should be the same color as the above (1) +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let from = neki; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +>from = a; // is a variable and should be in white color like other variables + ^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +> + ^ + source.ts +>exports.myVar = async (ctx, next) => {} // this is all in white but exports and async should be e.g. in red or blue + ^^^^^^^ + source.ts support.type.object.module.ts + ^ + source.ts punctuation.accessor.ts + ^^^^^ + source.ts entity.name.function.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^^^^^ + source.ts meta.arrow.ts storage.modifier.async.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^ + source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts + ^^^^ + source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +> + ^ + source.ts +>t.me = 1; + ^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^ + source.ts variable.other.property.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +>t.is = 2; // `is` is in blue but should be the same color as the above (1) + ^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^ + source.ts variable.other.property.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>t.in = 3; // `in` is in blue but should be the same color as the above (1) + ^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^ + source.ts variable.other.property.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>t.of = 4; // `of` is in blue but should be the same color as the above (1) + ^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^ + source.ts variable.other.property.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts \ No newline at end of file diff --git a/tests/baselines/Issue215.baseline.txt b/tests/baselines/Issue215.baseline.txt new file mode 100644 index 00000000..0a699611 --- /dev/null +++ b/tests/baselines/Issue215.baseline.txt @@ -0,0 +1,142 @@ +original file +----------------------------------- +function test() { + for (var i=0 ; ifunction test() { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> for (var i=0 ; i + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts +> } + ^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>for (var i=0 ; i + ^ + source.ts meta.block.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue216.baseline.txt b/tests/baselines/Issue216.baseline.txt new file mode 100644 index 00000000..c6e096e7 --- /dev/null +++ b/tests/baselines/Issue216.baseline.txt @@ -0,0 +1,114 @@ +original file +----------------------------------- +class MyType +{ + public myFunction = (): void => + { + // From this point on the syntax highlighting will be confused as to where it is. + var myVar = 5; + console.log("Hello there!"); + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class MyType + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts +>{ + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> public myFunction = (): void => + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.return.type.arrow.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.return.type.arrow.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.return.type.arrow.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts storage.type.function.arrow.ts +> { + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> // From this point on the syntax highlighting will be confused as to where it is. + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts comment.line.double-slash.ts +> var myVar = 5; + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> console.log("Hello there!"); + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts + ^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue217.baseline.txt b/tests/baselines/Issue217.baseline.txt new file mode 100644 index 00000000..22690ef4 --- /dev/null +++ b/tests/baselines/Issue217.baseline.txt @@ -0,0 +1,180 @@ +original file +----------------------------------- +export class StatusSelector { + @Output() select = new EventEmitter() + statuses = ["started", "completed"] +} + +export class StatusSelector2 { + @Output() select = new EventEmitter(); + statuses = ["started", "completed"] +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export class StatusSelector { + ^^^^^^ + source.ts meta.class.ts keyword.control.export.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> @Output() select = new EventEmitter() + ^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.decorator.ts punctuation.decorator.ts + ^^^^^^ + source.ts meta.class.ts meta.decorator.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.function-call.ts support.class.node.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.brace.round.ts +> statuses = ["started", "completed"] + ^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>export class StatusSelector2 { + ^^^^^^ + source.ts meta.class.ts keyword.control.export.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> @Output() select = new EventEmitter(); + ^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.decorator.ts punctuation.decorator.ts + ^^^^^^ + source.ts meta.class.ts meta.decorator.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.function-call.ts support.class.node.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> statuses = ["started", "completed"] + ^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.array.literal.ts meta.brace.square.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue218.baseline.txt b/tests/baselines/Issue218.baseline.txt new file mode 100644 index 00000000..faa7c660 --- /dev/null +++ b/tests/baselines/Issue218.baseline.txt @@ -0,0 +1,82 @@ +original file +----------------------------------- +class A { + foo(a, b) { + } + [foo](a, b) { + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class A { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> foo(a, b) { + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> [foo](a, b) { + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue219.baseline.txt b/tests/baselines/Issue219.baseline.txt new file mode 100644 index 00000000..f77de80e --- /dev/null +++ b/tests/baselines/Issue219.baseline.txt @@ -0,0 +1,80 @@ +original file +----------------------------------- +const { + map, + coordinate +} = this.props +if (!map) return; +var marker; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts punctuation.definition.binding-pattern.object.ts + ^^ + source.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts +> map, + ^^^^ + source.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts + ^^^ + source.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts punctuation.separator.comma.ts + ^^ + source.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts +> coordinate + ^^^^ + source.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts meta.definition.variable.ts variable.other.constant.ts + ^^ + source.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts +>} = this.props + ^ + source.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts punctuation.definition.binding-pattern.object.ts + ^ + source.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts variable.language.this.ts + ^ + source.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.var.expr.ts variable.other.property.ts +>if (!map) return; + ^^ + source.ts keyword.control.conditional.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts keyword.operator.logical.ts + ^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^^^^^ + source.ts keyword.control.flow.ts + ^ + source.ts punctuation.terminator.statement.ts +>var marker; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue22.baseline.txt b/tests/baselines/Issue22.baseline.txt new file mode 100644 index 00000000..be9f8ab9 --- /dev/null +++ b/tests/baselines/Issue22.baseline.txt @@ -0,0 +1,54 @@ +original file +----------------------------------- +app.get('/test/', (req, res) => { +}); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>app.get('/test/', (req, res) => { + ^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts string.quoted.single.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^ + source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts + ^^^ + source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +>}); + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue221.baseline.txt b/tests/baselines/Issue221.baseline.txt new file mode 100644 index 00000000..0b53c095 --- /dev/null +++ b/tests/baselines/Issue221.baseline.txt @@ -0,0 +1,116 @@ +original file +----------------------------------- +class syntaxHighlightBug { + + variable = + {"example":1}; + + public wronglyHighlitedCode() { + var a = 1; + return; + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class syntaxHighlightBug { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> variable = + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts +> {"example":1}; + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.objectliteral.ts meta.object.member.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.class.ts +> public wronglyHighlitedCode() { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> var a = 1; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> return; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue223.baseline.txt b/tests/baselines/Issue223.baseline.txt new file mode 100644 index 00000000..20b87ea2 --- /dev/null +++ b/tests/baselines/Issue223.baseline.txt @@ -0,0 +1,102 @@ +original file +----------------------------------- +for (i = 0; ifor (i = 0; i if (foo) { + ^^ + source.ts meta.block.ts + ^^ + source.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> bar = true + ^^^^ + source.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts meta.block.ts + ^^^^ + source.ts meta.block.ts meta.block.ts constant.language.boolean.true.ts + ^^ + source.ts meta.block.ts meta.block.ts +> break + ^^^^ + source.ts meta.block.ts meta.block.ts + ^^^^^ + source.ts meta.block.ts meta.block.ts keyword.control.loop.ts + ^^ + source.ts meta.block.ts meta.block.ts +> } + ^^ + source.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue226.baseline.txt b/tests/baselines/Issue226.baseline.txt new file mode 100644 index 00000000..7877e568 --- /dev/null +++ b/tests/baselines/Issue226.baseline.txt @@ -0,0 +1,68 @@ +original file +----------------------------------- +async function x() { + +} +const y = async () => { } +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>async function x() { + ^^^^^ + source.ts meta.function.ts storage.modifier.async.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.function.ts meta.block.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>const y = async () => { } + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.modifier.async.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue230.baseline.txt b/tests/baselines/Issue230.baseline.txt new file mode 100644 index 00000000..5c385e20 --- /dev/null +++ b/tests/baselines/Issue230.baseline.txt @@ -0,0 +1,314 @@ +original file +----------------------------------- +// Note: `new Date` without parenthesis (`new Date()`) +ctrl.filter("dateFilter", () => (input: mycivis.IAll[], date: Date = new Date) => input.filter((value, index, array) => { + let date2 = value.date || (value.day) ? moment(`${value.day} ${value.time}`, "YYYY-MM-DD HH:mm").toDate() : next_wday(value.wday); + + return moment(date).format("DD/MMM/YYYY") === moment(date2).format("DD/MMM/YYYY"); +})); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>// Note: `new Date` without parenthesis (`new Date()`) + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>ctrl.filter("dateFilter", () => (input: mycivis.IAll[], date: Date = new Date) => input.filter((value, index, array) => { + ^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^ + source.ts string.quoted.double.ts + ^ + source.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.module.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts punctuation.accessor.ts + ^^^^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts + ^^^^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts keyword.operator.assignment.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts + ^^^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts new.expr.ts + ^^^^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts new.expr.ts support.class.builtin.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.arrow.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts + ^^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts + ^^^^^ + source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts + ^^^^^ + source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> let date2 = value.date || (value.day) ? moment(`${value.day} ${value.time}`, "YYYY-MM-DD HH:mm").toDate() : next_wday(value.wday); + ^^^^ + source.ts meta.arrow.ts meta.block.ts + ^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.logical.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.object.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts punctuation.accessor.ts + ^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.property.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.template.ts + ^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.object.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts punctuation.accessor.ts + ^^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.property.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.arrow.ts meta.block.ts +> return moment(date).format("DD/MMM/YYYY") === moment(date2).format("DD/MMM/YYYY"); + ^^^^ + source.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^ + source.ts meta.arrow.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.arrow.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^^^ + source.ts meta.arrow.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^ + source.ts meta.arrow.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.arrow.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +>})); + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue232.baseline.txt b/tests/baselines/Issue232.baseline.txt new file mode 100644 index 00000000..5558e473 --- /dev/null +++ b/tests/baselines/Issue232.baseline.txt @@ -0,0 +1,88 @@ +original file +----------------------------------- +for( let [k, component] of this.components){ + let bounds = component.view.getBounds(); /// <= not highlighted, nor anything after this +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>for( let [k, component] of this.components){ + ^^^ + source.ts keyword.control.loop.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts + ^ + source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts punctuation.definition.binding-pattern.array.ts + ^ + source.ts meta.var.expr.ts meta.array-binding-pattern-variable.ts + ^^ + source.ts keyword.operator.expression.of.ts + ^ + source.ts + ^^^^ + source.ts variable.language.this.ts + ^ + source.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts support.variable.property.dom.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> let bounds = component.view.getBounds(); /// <= not highlighted, nor anything after this + ^^^^ + source.ts meta.block.ts + ^^^ + source.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.block.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts meta.var.expr.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.block.ts + ^^ + source.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts comment.line.double-slash.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue235.baseline.txt b/tests/baselines/Issue235.baseline.txt new file mode 100644 index 00000000..d5843c33 --- /dev/null +++ b/tests/baselines/Issue235.baseline.txt @@ -0,0 +1,106 @@ +original file +----------------------------------- +class A { + @Route.GET('/*') + get(q: Request, s: Response): void { + s.sendFile(); + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class A { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> @Route.GET('/*') + ^^^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.decorator.ts punctuation.decorator.ts + ^^^^^ + source.ts meta.class.ts meta.decorator.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.decorator.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.decorator.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.class.ts meta.decorator.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.decorator.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.decorator.ts meta.brace.round.ts +> get(q: Request, s: Response): void { + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> s.sendFile(); + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue236.baseline.txt b/tests/baselines/Issue236.baseline.txt new file mode 100644 index 00000000..0656598e --- /dev/null +++ b/tests/baselines/Issue236.baseline.txt @@ -0,0 +1,134 @@ +original file +----------------------------------- +class Test { + public before() { + // ... + } + + public [Symbol.iterator]() { + // ... + } + + public after() { + // ... + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Test { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> public before() { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> // ... + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts comment.line.double-slash.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> public [Symbol.iterator]() { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts support.class.builtin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> // ... + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts comment.line.double-slash.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> public after() { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> // ... + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts comment.line.double-slash.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue237.baseline.txt b/tests/baselines/Issue237.baseline.txt new file mode 100644 index 00000000..a333600f --- /dev/null +++ b/tests/baselines/Issue237.baseline.txt @@ -0,0 +1,40 @@ +original file +----------------------------------- +export type Test = string // wrong comment color + // should be this +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export type Test = string // wrong comment color + ^^^^^^ + source.ts meta.type.declaration.ts keyword.control.export.ts + ^ + source.ts meta.type.declaration.ts + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^^^^^^ + source.ts meta.type.declaration.ts support.type.primitive.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.type.declaration.ts comment.line.double-slash.ts +> // should be this + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.type.declaration.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.type.declaration.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^ + source.ts meta.type.declaration.ts comment.line.double-slash.ts \ No newline at end of file diff --git a/tests/baselines/Issue239.baseline.txt b/tests/baselines/Issue239.baseline.txt new file mode 100644 index 00000000..e1ada6fc --- /dev/null +++ b/tests/baselines/Issue239.baseline.txt @@ -0,0 +1,76 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has jsx + const test = (true) ?

Broken Color

:

Also Broken Color

+----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has jsx + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx comment.line.double-slash.tsx +> const test = (true) ?

Broken Color

:

Also Broken Color

+ ^ + source.tsx + ^^^^^ + source.tsx meta.var.expr.tsx storage.type.tsx + ^ + source.tsx meta.var.expr.tsx + ^^^^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.definition.variable.tsx variable.other.constant.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx + ^ + source.tsx meta.var.expr.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx + ^ + source.tsx meta.var.expr.tsx meta.brace.round.tsx + ^^^^ + source.tsx meta.var.expr.tsx constant.language.boolean.true.tsx + ^ + source.tsx meta.var.expr.tsx meta.brace.round.tsx + ^ + source.tsx meta.var.expr.tsx + ^ + source.tsx meta.var.expr.tsx keyword.operator.ternary.tsx + ^ + source.tsx meta.var.expr.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.var.expr.tsx + ^ + source.tsx meta.var.expr.tsx keyword.operator.ternary.tsx + ^ + source.tsx meta.var.expr.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.var.expr.tsx \ No newline at end of file diff --git a/tests/baselines/Issue241.baseline.txt b/tests/baselines/Issue241.baseline.txt new file mode 100644 index 00000000..93b4f292 --- /dev/null +++ b/tests/baselines/Issue241.baseline.txt @@ -0,0 +1,330 @@ +original file +----------------------------------- +function f(): () => number { + const x = 0; +} +function foo(): [number, () => number] { + const x = 0; +} +function f(): () => number { + const x = 0; +} +function f2(): () => {x: number }{ + const x = 0; +} +function foo2(): [number, () => { x: number }] { + const x = 0; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function f(): () => number { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> const x = 0; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>function foo(): [number, () => number] { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> const x = 0; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>function f(): () => number { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> const x = 0; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>function f2(): () => {x: number }{ + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> const x = 0; + ^^^^ + source.ts meta.block.ts + ^^^^^ + source.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts +>function foo2(): [number, () => { x: number }] { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.return.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.return.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.return.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.return.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.return.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.return.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.return.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.return.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.type.function.return.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> const x = 0; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue243.baseline.txt b/tests/baselines/Issue243.baseline.txt new file mode 100644 index 00000000..b86bc701 --- /dev/null +++ b/tests/baselines/Issue243.baseline.txt @@ -0,0 +1,2508 @@ +original file +----------------------------------- +'use strict'; + + var pieces = []; + var numeration = []; + + for (var i in pieces) { + switch (true) { + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + } + } + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>'use strict'; + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^ + source.ts string.quoted.single.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +> var pieces = []; + ^^^^^^^^ + source.ts + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts punctuation.terminator.statement.ts +> var numeration = []; + ^^^^^^^^ + source.ts + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +> for (var i in pieces) { + ^^^^^^^^ + source.ts + ^^^ + source.ts keyword.control.loop.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^^ + source.ts keyword.operator.expression.in.ts + ^ + source.ts + ^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> switch (true) { + ^^^^^^^^^^^^ + source.ts meta.block.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts constant.language.boolean.true.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.definition.block.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case /^\"?Accession\"?/.test(pieces[i]): + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.control.anchor.regexp + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> numeration[0] = i; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> break; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts punctuation.definition.block.ts +> } + ^^^^^^^^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue244.baseline.txt b/tests/baselines/Issue244.baseline.txt new file mode 100644 index 00000000..f90c8045 --- /dev/null +++ b/tests/baselines/Issue244.baseline.txt @@ -0,0 +1,164 @@ +original file +----------------------------------- +a.withLatestFrom(axis === 'x' ? initialX : initialY) + .map(x => undefined) + .switch() + .publish().refCount(); + +const targetX = targetSideObs('x'); +const targetY = targetSideObs('y'); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>a.withLatestFrom(axis === 'x' ? initialX : initialY) + ^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^^^ + source.ts keyword.operator.comparison.ts + ^ + source.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts string.quoted.single.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts + ^ + source.ts keyword.operator.ternary.ts + ^ + source.ts + ^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.ternary.ts + ^ + source.ts + ^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts +> .map(x => undefined) + ^ + source.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts + ^^^^^^^^^ + source.ts constant.language.undefined.ts + ^ + source.ts meta.brace.round.ts +> .switch() + ^ + source.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts +> .publish().refCount(); + ^ + source.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>const targetX = targetSideObs('x'); + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>const targetY = targetSideObs('y'); + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue247.baseline.txt b/tests/baselines/Issue247.baseline.txt new file mode 100644 index 00000000..4f2013c4 --- /dev/null +++ b/tests/baselines/Issue247.baseline.txt @@ -0,0 +1,44 @@ +original file +----------------------------------- +@dec<{}>() +class Test { +} + +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>@dec<{}>() + ^ + source.tsx meta.decorator.tsx punctuation.decorator.tsx + ^^^ + source.tsx meta.decorator.tsx meta.function-call.tsx entity.name.function.tsx + ^ + source.tsx meta.decorator.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + ^ + source.tsx meta.decorator.tsx meta.type.parameters.tsx meta.object.type.tsx punctuation.definition.block.tsx + ^ + source.tsx meta.decorator.tsx meta.type.parameters.tsx meta.object.type.tsx punctuation.definition.block.tsx + ^ + source.tsx meta.decorator.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + ^ + source.tsx meta.decorator.tsx meta.brace.round.tsx + ^ + source.tsx meta.decorator.tsx meta.brace.round.tsx +>class Test { + ^^^^^ + source.tsx meta.class.tsx storage.type.class.tsx + ^ + source.tsx meta.class.tsx + ^^^^ + source.tsx meta.class.tsx entity.name.type.class.tsx + ^ + source.tsx meta.class.tsx + ^ + source.tsx meta.class.tsx punctuation.definition.block.tsx +>} + ^ + source.tsx meta.class.tsx punctuation.definition.block.tsx +> + ^ + source.tsx \ No newline at end of file diff --git a/tests/baselines/Issue248.baseline.txt b/tests/baselines/Issue248.baseline.txt new file mode 100644 index 00000000..2ed61770 --- /dev/null +++ b/tests/baselines/Issue248.baseline.txt @@ -0,0 +1,570 @@ +original file +----------------------------------- +class C1 { + m1 = 1; + static s1() { + return [() => (new this).m1]; + } +} +class C2 { + m1 = 1; + static s1() { + return [() => (new this).m1]; + } +} +class C3 { + m1 = 1; + static s1() { + return [() => (new this).m1]; + } +} +class C4 { + m1 = 1; + static s1() { + return [() => (new this).m1]; + } +} +class C5 { + m1 = 1; + static s1() { + return [() => (new this).m1]; + } +} +class C6 { + m1 = 1; + static s1() { + return [() => (new this).m1]; + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class C1 { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> m1 = 1; + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> static s1() { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> return [() => (new this).m1]; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts punctuation.accessor.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class C2 { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> m1 = 1; + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> static s1() { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> return [() => (new this).m1]; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts punctuation.accessor.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class C3 { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> m1 = 1; + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> static s1() { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> return [() => (new this).m1]; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts punctuation.accessor.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class C4 { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> m1 = 1; + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> static s1() { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> return [() => (new this).m1]; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts punctuation.accessor.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class C5 { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> m1 = 1; + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> static s1() { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> return [() => (new this).m1]; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts punctuation.accessor.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class C6 { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> m1 = 1; + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> static s1() { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> return [() => (new this).m1]; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts punctuation.accessor.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue249.baseline.txt b/tests/baselines/Issue249.baseline.txt new file mode 100644 index 00000000..887ba852 --- /dev/null +++ b/tests/baselines/Issue249.baseline.txt @@ -0,0 +1,104 @@ +original file +----------------------------------- +const selectDictionary = (dictionaries: StoredDictionaries, lang:string) => { + +} + +function selectDictionary(dictionaries: StoredDictionaries, lang:string) { + +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const selectDictionary = (dictionaries: StoredDictionaries, lang:string) => { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts +>} + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>function selectDictionary(dictionaries: StoredDictionaries, lang:string) { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^^^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.function.ts meta.block.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue250.baseline.txt b/tests/baselines/Issue250.baseline.txt new file mode 100644 index 00000000..58b88aa9 --- /dev/null +++ b/tests/baselines/Issue250.baseline.txt @@ -0,0 +1,334 @@ +original file +----------------------------------- +/** Meta-part that defins a Form */ +export class FormType extends Type { + + /** @internal Original FormType instance */ + static Original = function () { + let type = new FormType; + + // define embed field + type.defineField(DesignID.Embed, new BooleanAtom(false)); + + // define plan choice + type.defineField(DesignID.Plan, PlanChoice.Original); + + // define fields list + let fields = + type.defineField(DesignID.Fields, new Ordering(new FieldDesign)); + // embed field list + fields.embed = true; + + return type; + } (); +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/** Meta-part that defins a Form */ + ^^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts + ^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +>export class FormType extends Type { + ^^^^^^ + source.ts meta.class.ts keyword.control.export.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> /** @internal Original FormType instance */ + ^^ + source.ts meta.class.ts + ^^^ + source.ts meta.class.ts comment.block.documentation.ts punctuation.definition.comment.ts + ^ + source.ts meta.class.ts comment.block.documentation.ts + ^ + source.ts meta.class.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts storage.type.class.jsdoc + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts comment.block.documentation.ts + ^^ + source.ts meta.class.ts comment.block.documentation.ts punctuation.definition.comment.ts +> static Original = function () { + ^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> let type = new FormType; + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts new.expr.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts new.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts +> // define embed field + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts comment.line.double-slash.ts +> type.defineField(DesignID.Embed, new BooleanAtom(false)); + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts new.expr.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts new.expr.ts constant.language.boolean.false.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts +> // define plan choice + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts comment.line.double-slash.ts +> type.defineField(DesignID.Plan, PlanChoice.Original); + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts +> // define fields list + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts comment.line.double-slash.ts +> let fields = + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts +> type.defineField(DesignID.Fields, new Ordering(new FieldDesign)); + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts new.expr.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts new.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts new.expr.ts new.expr.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts new.expr.ts new.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> // embed field list + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts comment.line.double-slash.ts +> fields.embed = true; + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts constant.language.boolean.true.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts +> return type; + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> } (); + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue251.baseline.txt b/tests/baselines/Issue251.baseline.txt new file mode 100644 index 00000000..35536aa6 --- /dev/null +++ b/tests/baselines/Issue251.baseline.txt @@ -0,0 +1,220 @@ +original file +----------------------------------- +for(var j=0; (jfor(var j=0; (j for(var k = 0; (k output.push( {h, w, x: k*w, y: h*j, file: file.file}); + ^^^^ + source.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.block.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts punctuation.separator.comma.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts punctuation.separator.comma.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts punctuation.separator.comma.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts punctuation.separator.comma.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts + ^^^^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^^^^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.object.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.property.ts + ^ + source.ts meta.block.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> l++; + ^^^^ + source.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^^ + source.ts meta.block.ts meta.block.ts keyword.operator.increment.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^ + source.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue252.baseline.txt b/tests/baselines/Issue252.baseline.txt new file mode 100644 index 00000000..21589ce0 --- /dev/null +++ b/tests/baselines/Issue252.baseline.txt @@ -0,0 +1,108 @@ +original file +----------------------------------- +function getPage(p, base) { + if (filename == base + "index") { var route = "/" + base } +} + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function getPage(p, base) { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> if (filename == base + "index") { var route = "/" + base } + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue262.baseline.txt b/tests/baselines/Issue262.baseline.txt new file mode 100644 index 00000000..c6fa8c88 --- /dev/null +++ b/tests/baselines/Issue262.baseline.txt @@ -0,0 +1,122 @@ +original file +----------------------------------- +for (let a = 1; a < 10; a++) { + for (let b = 1; b < a; b++) { + + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>for (let a = 1; a < 10; a++) { + ^^^ + source.ts keyword.control.loop.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.relational.ts + ^ + source.ts + ^^ + source.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^^ + source.ts keyword.operator.increment.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> for (let b = 1; b < a; b++) { + ^^^^ + source.ts meta.block.ts + ^^^ + source.ts meta.block.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts variable.other.readwrite.ts + ^^ + source.ts meta.block.ts keyword.operator.increment.ts + ^ + source.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> + ^^^^^^^^^ + source.ts meta.block.ts meta.block.ts +> } + ^^^^ + source.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue262.txt b/tests/baselines/Issue262.txt deleted file mode 100644 index ccad30f4..00000000 --- a/tests/baselines/Issue262.txt +++ /dev/null @@ -1,5 +0,0 @@ -[1, 6]: source.ts storage.type.ts -[1, 19]: source.ts keyword.operator.comparison.ts -[2, 5]: source.ts meta.block.ts keyword.control.ts -[2, 10]: source.ts meta.block.ts storage.type.ts -[3, 9]: source.ts meta.block.ts meta.block.ts diff --git a/tests/baselines/Issue264.baseline.txt b/tests/baselines/Issue264.baseline.txt new file mode 100644 index 00000000..4594a679 --- /dev/null +++ b/tests/baselines/Issue264.baseline.txt @@ -0,0 +1,52 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has jsx + +
+
+ +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has jsx + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx comment.line.double-slash.tsx +> + ^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^ + source.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx support.class.component.tsx + ^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
+ ^^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx + ^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
+ ^^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +> + ^^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^ + source.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx support.class.component.tsx + ^ + source.tsx meta.tag.without-attributes.tsx + ^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx \ No newline at end of file diff --git a/tests/baselines/Issue276.baseline.txt b/tests/baselines/Issue276.baseline.txt new file mode 100644 index 00000000..1459d566 --- /dev/null +++ b/tests/baselines/Issue276.baseline.txt @@ -0,0 +1,146 @@ +original file +----------------------------------- +/** + * @param {string} value + * @param {string[]} arrayValue + * @param {string} [optionalValue] + */ +function test(value: string, arrayValue: string[], optionalValue?: string) { + +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/** + ^^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +> * @param {string} value + ^^^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc + ^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.begin.jsdoc + ^^^^^^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.end.jsdoc + ^ + source.ts comment.block.documentation.ts + ^^^^^ + source.ts comment.block.documentation.ts variable.other.jsdoc +> * @param {string[]} arrayValue + ^^^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc + ^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.begin.jsdoc + ^^^^^^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.end.jsdoc + ^ + source.ts comment.block.documentation.ts + ^^^^^^^^^^ + source.ts comment.block.documentation.ts variable.other.jsdoc +> * @param {string} [optionalValue] + ^^^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc + ^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.begin.jsdoc + ^^^^^^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.end.jsdoc + ^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts variable.other.jsdoc punctuation.definition.optional-value.begin.bracket.square.jsdoc + ^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts variable.other.jsdoc + ^ + source.ts comment.block.documentation.ts variable.other.jsdoc punctuation.definition.optional-value.end.bracket.square.jsdoc +> */ + ^ + source.ts comment.block.documentation.ts + ^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +>function test(value: string, arrayValue: string[], optionalValue?: string) { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^^^^^^^^^^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts keyword.operator.optional.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.function.ts meta.block.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue28.baseline.txt b/tests/baselines/Issue28.baseline.txt new file mode 100644 index 00000000..e0efc91a --- /dev/null +++ b/tests/baselines/Issue28.baseline.txt @@ -0,0 +1,134 @@ +original file +----------------------------------- + +/* Testing octals */ + +var x = 123; +var y = 0x123; +var z = 0b10101; +var z = 0B00000; +var j = 0o474774; +var w = 0O767; + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +> + ^ + source.ts +>/* Testing octals */ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +> + ^ + source.ts +>var x = 123; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +>var y = 0x123; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts constant.numeric.hex.ts + ^ + source.ts punctuation.terminator.statement.ts +>var z = 0b10101; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts constant.numeric.binary.ts + ^ + source.ts punctuation.terminator.statement.ts +>var z = 0B00000; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts constant.numeric.binary.ts + ^ + source.ts punctuation.terminator.statement.ts +>var j = 0o474774; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts constant.numeric.octal.ts + ^ + source.ts punctuation.terminator.statement.ts +>var w = 0O767; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts constant.numeric.octal.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue28.txt b/tests/baselines/Issue28.txt deleted file mode 100644 index 1c8d244a..00000000 --- a/tests/baselines/Issue28.txt +++ /dev/null @@ -1,7 +0,0 @@ -[4, 9]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[5, 9]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[6, 9]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[7, 9]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[8, 9]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[9, 9]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts constant.numeric.ts -[10, 1]: source.ts \ No newline at end of file diff --git a/tests/baselines/Issue280.baseline.txt b/tests/baselines/Issue280.baseline.txt new file mode 100644 index 00000000..a22941bd --- /dev/null +++ b/tests/baselines/Issue280.baseline.txt @@ -0,0 +1,354 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has jsx +class c { + private renderForecastsTable() { + let forecasts = this.props.forecasts.map(forecast => { + return forecast.dateFormatted + + forecast.temperatureC + + forecast.temperatureF + + forecast.summar; + }); + return + + + + { + this.props.forecasts.map(forecast => { + return forecast.dateFormatted + + forecast.temperatureC + + forecast.temperatureF + + forecast.summar; + }) + } + +
; + } + +} +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has jsx + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx comment.line.double-slash.tsx +>class c { + ^^^^^ + source.tsx meta.class.tsx storage.type.class.tsx + ^ + source.tsx meta.class.tsx + ^ + source.tsx meta.class.tsx entity.name.type.class.tsx + ^ + source.tsx meta.class.tsx + ^ + source.tsx meta.class.tsx punctuation.definition.block.tsx +> private renderForecastsTable() { + ^ + source.tsx meta.class.tsx + ^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx storage.modifier.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx + ^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.definition.method.tsx entity.name.function.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx punctuation.definition.block.tsx +> let forecasts = this.props.forecasts.map(forecast => { + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx storage.type.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx + ^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.definition.variable.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.function-call.tsx variable.language.this.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.function-call.tsx variable.other.object.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.function-call.tsx variable.other.object.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.function-call.tsx entity.name.function.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.brace.round.tsx + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx variable.parameter.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx storage.type.function.arrow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx punctuation.definition.block.tsx +> return forecast.dateFormatted + + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx keyword.control.flow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx variable.other.object.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx punctuation.accessor.tsx + ^^^^^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx variable.other.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx keyword.operator.arithmetic.tsx +> forecast.temperatureC + + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx variable.other.object.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx punctuation.accessor.tsx + ^^^^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx variable.other.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx keyword.operator.arithmetic.tsx +> forecast.temperatureF + + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx variable.other.object.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx punctuation.accessor.tsx + ^^^^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx variable.other.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx keyword.operator.arithmetic.tsx +> forecast.summar; + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx variable.other.object.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx punctuation.accessor.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx variable.other.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx punctuation.terminator.statement.tsx +> }); + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx punctuation.definition.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.var.expr.tsx meta.brace.round.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx punctuation.terminator.statement.tsx +> return + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx keyword.control.flow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.double.tsx punctuation.definition.string.begin.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.double.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.double.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx punctuation.definition.tag.end.tsx +> + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +> + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +> + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +> { + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx punctuation.section.embedded.begin.tsx +> this.props.forecasts.map(forecast => { + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx variable.language.this.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx variable.other.object.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx variable.other.object.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx entity.name.function.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.brace.round.tsx + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx variable.parameter.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx storage.type.function.arrow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx punctuation.definition.block.tsx +> return forecast.dateFormatted + + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx keyword.control.flow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx variable.other.object.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx punctuation.accessor.tsx + ^^^^^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx variable.other.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx keyword.operator.arithmetic.tsx +> forecast.temperatureC + + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx variable.other.object.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx punctuation.accessor.tsx + ^^^^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx variable.other.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx keyword.operator.arithmetic.tsx +> forecast.temperatureF + + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx variable.other.object.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx punctuation.accessor.tsx + ^^^^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx variable.other.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx keyword.operator.arithmetic.tsx +> forecast.summar; + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx variable.other.object.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx punctuation.accessor.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx variable.other.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx punctuation.terminator.statement.tsx +> }) + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.arrow.tsx meta.block.tsx punctuation.definition.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.brace.round.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx +> } + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx punctuation.section.embedded.end.tsx +> + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
; + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx punctuation.terminator.statement.tsx +> } + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx punctuation.definition.block.tsx +> + ^ + source.tsx meta.class.tsx +>} + ^ + source.tsx meta.class.tsx punctuation.definition.block.tsx \ No newline at end of file diff --git a/tests/baselines/Issue283.baseline.txt b/tests/baselines/Issue283.baseline.txt new file mode 100644 index 00000000..5b8d1643 --- /dev/null +++ b/tests/baselines/Issue283.baseline.txt @@ -0,0 +1,722 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has jsx +import * as React from 'react'; + +export default class Home extends React.Component { + public render() { + return
+

Hello, world!

+

Welcome to your new single-page application, built with:

+ +

To help you get started, we've also set up:

+
    +
  • Client-side navigation. For example, click Counter then Back to return here.
    • +
  • Webpack dev middleware. In development mode, there's no need to run the webpack build tool. Your client-side resources are dynamically built on demand. Updates are available as soon as you modify any file.
    • +
  • Hot module replacement. In development mode, you don't even need to reload the page after making most changes. Within seconds of saving changes to files, rebuilt React components will be injected directly into your running application, preserving its live state.
    • +
  • Efficient production builds. In production mode, development-time features are disabled, and the webpack build tool produces minified static CSS and JavaScript files.
    • +
  • Server-side prerendering. To optimize startup time, your React application is first rendered on the server. The initial HTML and state is then transferred to the browser, where client-side code picks up where the server left off.
    • +
+
; + } +} +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has jsx + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx comment.line.double-slash.tsx +>import * as React from 'react'; + ^^^^^^ + source.tsx meta.import.tsx keyword.control.import.tsx + ^ + source.tsx meta.import.tsx + ^ + source.tsx meta.import.tsx constant.language.import-export-all.tsx + ^ + source.tsx meta.import.tsx + ^^ + source.tsx meta.import.tsx keyword.control.as.tsx + ^ + source.tsx meta.import.tsx + ^^^^^ + source.tsx meta.import.tsx variable.other.readwrite.alias.tsx + ^ + source.tsx meta.import.tsx + ^^^^ + source.tsx meta.import.tsx keyword.control.from.tsx + ^ + source.tsx meta.import.tsx + ^ + source.tsx meta.import.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^^^^^ + source.tsx meta.import.tsx string.quoted.single.tsx + ^ + source.tsx meta.import.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +> + ^ + source.tsx +>export default class Home extends React.Component { + ^^^^^^ + source.tsx meta.export.default.tsx keyword.control.export.tsx + ^ + source.tsx meta.export.default.tsx + ^^^^^^^ + source.tsx meta.export.default.tsx keyword.control.default.tsx + ^ + source.tsx meta.export.default.tsx + ^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx storage.type.class.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx entity.name.type.class.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx + ^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx storage.modifier.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx + ^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx entity.name.type.module.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx punctuation.accessor.tsx + ^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx entity.other.inherited-class.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + ^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.type.parameters.tsx support.type.primitive.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.type.parameters.tsx punctuation.separator.comma.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.type.parameters.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.type.parameters.tsx support.type.primitive.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx punctuation.definition.block.tsx +> public render() { + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx storage.modifier.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.definition.method.tsx entity.name.function.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx punctuation.definition.block.tsx +> return
+ ^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx keyword.control.flow.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>

Hello, world!

+ ^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>

Welcome to your new single-page application, built with:

+ ^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
    + ^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
  • ASP.NET Core and C# for cross-platform server-side code
    • + ^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
  • React, Redux, and TypeScript for client-side code
    • + ^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
  • Webpack for building and bundling client-side resources
    • + ^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
  • Bootstrap for layout and styling
    • + ^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
+ ^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>

To help you get started, we've also set up:

+ ^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
    + ^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
  • Client-side navigation. For example, click Counter then Back to return here.
    • + ^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
  • Webpack dev middleware. In development mode, there's no need to run the webpack build tool. Your client-side resources are dynamically built on demand. Updates are available as soon as you modify any file.
    • + ^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
  • Hot module replacement. In development mode, you don't even need to reload the page after making most changes. Within seconds of saving changes to files, rebuilt React components will be injected directly into your running application, preserving its live state.
    • + ^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
  • Efficient production builds. In production mode, development-time features are disabled, and the webpack build tool produces minified static CSS and JavaScript files.
    • + ^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
  • Server-side prerendering. To optimize startup time, your React application is first rendered on the server. The initial HTML and state is then transferred to the browser, where client-side code picks up where the server left off.
    • + ^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
+ ^^^^^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx +>
; + ^^^^^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx punctuation.terminator.statement.tsx +> } + ^^^^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^ + source.tsx meta.export.default.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx punctuation.definition.block.tsx +>} + ^ + source.tsx meta.export.default.tsx meta.class.tsx punctuation.definition.block.tsx \ No newline at end of file diff --git a/tests/baselines/Issue285.baseline.txt b/tests/baselines/Issue285.baseline.txt new file mode 100644 index 00000000..184cbafc --- /dev/null +++ b/tests/baselines/Issue285.baseline.txt @@ -0,0 +1,70 @@ +original file +----------------------------------- +let model = { + links: { + new: "sample" + }, + }; + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let model = { + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> links: { + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts +> new: "sample" + ^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts +> }, + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> }; + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue288.baseline.txt b/tests/baselines/Issue288.baseline.txt new file mode 100644 index 00000000..484a0bbb --- /dev/null +++ b/tests/baselines/Issue288.baseline.txt @@ -0,0 +1,240 @@ +original file +----------------------------------- +// Issue 288: "function" in "functionName" gets highlighted. +// Fixed in pull request #289. + +function Name(){ +} +var AnotherName = function(){ +} + +export function eName(){ +} +export var eAnotherName = function(){ +} + +var functionName=1; +functionName=1; + +export var functionName2=1; + +var exportName="hello"; +exportName2="hello"; + +var returnName=1; +returnName+=1; + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>// Issue 288: "function" in "functionName" gets highlighted. + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>// Fixed in pull request #289. + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +> + ^ + source.ts +>function Name(){ + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>var AnotherName = function(){ + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>export function eName(){ + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>export var eAnotherName = function(){ + ^^^^^^ + source.ts meta.var.expr.ts keyword.control.export.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>var functionName=1; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +>functionName=1; + ^^^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>export var functionName2=1; + ^^^^^^ + source.ts meta.var.expr.ts keyword.control.export.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>var exportName="hello"; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>exportName2="hello"; + ^^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts string.quoted.double.ts + ^ + source.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>var returnName=1; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +>returnName+=1; + ^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^^ + source.ts keyword.operator.assignment.compound.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue288.txt b/tests/baselines/Issue288.txt deleted file mode 100644 index ceefa59c..00000000 --- a/tests/baselines/Issue288.txt +++ /dev/null @@ -1,11 +0,0 @@ -[4, 10]: source.ts meta.function.ts entity.name.function.ts -[6, 27]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.function.ts meta.function.type.parameter.ts meta.brace.round.ts -[9, 17]: source.ts meta.function.ts entity.name.function.ts -[11, 35]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.function.ts meta.function.type.parameter.ts meta.brace.round.ts -[14, 13]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts variable.ts -[15, 9]: source.ts -[17, 20]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts variable.ts -[19, 11]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts variable.ts -[20, 7]: source.ts -[22, 11]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts variable.ts -[23, 7]: source.ts \ No newline at end of file diff --git a/tests/baselines/Issue292.baseline.txt b/tests/baselines/Issue292.baseline.txt new file mode 100644 index 00000000..b2bd9a99 --- /dev/null +++ b/tests/baselines/Issue292.baseline.txt @@ -0,0 +1,124 @@ +original file +----------------------------------- + const shellOptions: IOptions = { + filesToOpen, + filesToCreate, + filesToDiff + }; + const a = { + filesToOpen: filesToOpen, + filesToCreate: filesToCreate, + filesToDiff: filesToDiff + } +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +> const shellOptions: IOptions = { + ^^^^ + source.ts + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> filesToOpen, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> filesToCreate, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> filesToDiff + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts +> }; + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts +> const a = { + ^^^^ + source.ts + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> filesToOpen: filesToOpen, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> filesToCreate: filesToCreate, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> filesToDiff: filesToDiff + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts +> } + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue294.baseline.txt b/tests/baselines/Issue294.baseline.txt new file mode 100644 index 00000000..dd8fe969 --- /dev/null +++ b/tests/baselines/Issue294.baseline.txt @@ -0,0 +1,80 @@ +original file +----------------------------------- +switch (0) { + case 0: { + const zero = 0; + return zero; + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>switch (0) { + ^^^^^^ + source.ts switch-statement.expr.ts switch-expression.expr.ts keyword.control.switch.ts + ^ + source.ts switch-statement.expr.ts switch-expression.expr.ts + ^ + source.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts + ^ + source.ts switch-statement.expr.ts switch-expression.expr.ts constant.numeric.decimal.ts + ^ + source.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts + ^ + source.ts switch-statement.expr.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts punctuation.definition.block.ts +> case 0: { + ^^^^ + source.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts constant.numeric.decimal.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts punctuation.definition.block.ts +> const zero = 0; + ^^^^^^^^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts + ^^^^^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts meta.var.expr.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts punctuation.terminator.statement.ts +> return zero; + ^^^^^^^^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts + ^^^^^^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts + ^^^^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts + ^ + source.ts switch-statement.expr.ts switch-block.expr.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts switch-statement.expr.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue3.baseline.txt b/tests/baselines/Issue3.baseline.txt new file mode 100644 index 00000000..3692e1d2 --- /dev/null +++ b/tests/baselines/Issue3.baseline.txt @@ -0,0 +1,34 @@ +original file +----------------------------------- +let regex = /**/ /foo/; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let regex = /**/ /foo/; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts string.regexp.ts + ^ + source.ts meta.var.expr.ts string.regexp.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.var.expr.ts string.regexp.ts + ^ + source.ts meta.var.expr.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue304.baseline.txt b/tests/baselines/Issue304.baseline.txt new file mode 100644 index 00000000..7240fc02 --- /dev/null +++ b/tests/baselines/Issue304.baseline.txt @@ -0,0 +1,214 @@ +original file +----------------------------------- +export const EditorPanel = connect( + (state: Immutable): Object => ( { + edditorState: (state.editors[state.activeTab]), + macroSettingsOpen: state.macroSettingsOpen, + }), + (dispatch: Dispatch): Object => ({ + onchange(next: EditorSDtate): void { dispatch(actions) } + }) +) +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export const EditorPanel = connect( + ^^^^^^ + source.ts meta.var.expr.ts keyword.control.export.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts +> (state: Immutable): Object => ( { + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> edditorState: (state.editors[state.activeTab]), + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.property.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts meta.brace.square.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts variable.other.property.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> macroSettingsOpen: state.macroSettingsOpen, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.property.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> }), + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts +> (dispatch: Dispatch): Object => ({ + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> onchange(next: EditorSDtate): void { dispatch(actions) } + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.return.type.ts + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> }) + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts +>) + ^ + source.ts meta.var.expr.ts meta.brace.round.ts \ No newline at end of file diff --git a/tests/baselines/Issue305.baseline.txt b/tests/baselines/Issue305.baseline.txt new file mode 100644 index 00000000..7364262a --- /dev/null +++ b/tests/baselines/Issue305.baseline.txt @@ -0,0 +1,112 @@ +original file +----------------------------------- +abstract class Base { + protected abstract topic: string + constructor(protected wire: Transport, protected token?: string, readonly bar?: boolean) { } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>abstract class Base { + ^^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> protected abstract topic: string + ^^^^ + source.ts meta.class.ts + ^^^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts +> constructor(protected wire: Transport, protected token?: string, readonly bar?: boolean) { } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts keyword.operator.optional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts keyword.operator.optional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue307.baseline.txt b/tests/baselines/Issue307.baseline.txt new file mode 100644 index 00000000..c7bfb4c6 --- /dev/null +++ b/tests/baselines/Issue307.baseline.txt @@ -0,0 +1,136 @@ +original file +----------------------------------- +class Test { + method() { + const obj = { a: 'hello' }; + const { + a + } = obj; + const x = 'world'; + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Test { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> method() { + ^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> const obj = { a: 'hello' }; + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> const { + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts punctuation.definition.binding-pattern.object.ts +> a + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts meta.definition.variable.ts variable.other.constant.ts +> } = obj; + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts punctuation.definition.binding-pattern.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> const x = 'world'; + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue314.baseline.txt b/tests/baselines/Issue314.baseline.txt new file mode 100644 index 00000000..ba5db05c --- /dev/null +++ b/tests/baselines/Issue314.baseline.txt @@ -0,0 +1,66 @@ +original file +----------------------------------- +let x = a ? b as X : c; +let y = 123; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let x = a ? b as X : c; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts keyword.control.as.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +>let y = 123; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue318.baseline.txt b/tests/baselines/Issue318.baseline.txt new file mode 100644 index 00000000..8fe1b543 --- /dev/null +++ b/tests/baselines/Issue318.baseline.txt @@ -0,0 +1,184 @@ +original file +----------------------------------- + this.Then( + /^display prompt in branch "([^"]*)"$/, + async function (branchName) { + const expected = application.prompt(branchName); + const actual = await application.getOnceOut(); + expect(actual).to.be.equal(expected); + } + ); + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +> this.Then( + ^^^^ + source.ts + ^^^^ + source.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts +> /^display prompt in branch "([^"]*)"$/, + ^^^^^^^^ + source.ts + ^ + source.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts string.regexp.ts keyword.control.anchor.regexp + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts string.regexp.ts + ^ + source.ts string.regexp.ts meta.group.regexp punctuation.definition.group.regexp + ^ + source.ts string.regexp.ts meta.group.regexp constant.other.character-class.set.regexp punctuation.definition.character-class.regexp + ^ + source.ts string.regexp.ts meta.group.regexp constant.other.character-class.set.regexp keyword.operator.negation.regexp + ^ + source.ts string.regexp.ts meta.group.regexp constant.other.character-class.set.regexp + ^ + source.ts string.regexp.ts meta.group.regexp constant.other.character-class.set.regexp punctuation.definition.character-class.regexp + ^ + source.ts string.regexp.ts meta.group.regexp keyword.operator.quantifier.regexp + ^ + source.ts string.regexp.ts meta.group.regexp punctuation.definition.group.regexp + ^ + source.ts string.regexp.ts + ^ + source.ts string.regexp.ts keyword.control.anchor.regexp + ^ + source.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.separator.comma.ts +> async function (branchName) { + ^^^^^^^^ + source.ts + ^^^^^ + source.ts meta.function.expression.ts storage.modifier.async.ts + ^ + source.ts meta.function.expression.ts + ^^^^^^^^ + source.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.function.expression.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^^^^ + source.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.expression.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> const expected = application.prompt(branchName); + ^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> const actual = await application.getOnceOut(); + ^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.control.flow.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> expect(actual).to.be.equal(expected); + ^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.object.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.object.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> ); + ^^^^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue32.baseline.txt b/tests/baselines/Issue32.baseline.txt new file mode 100644 index 00000000..79063798 --- /dev/null +++ b/tests/baselines/Issue32.baseline.txt @@ -0,0 +1,210 @@ +original file +----------------------------------- +/* + Testing Isuue 32: Adding constructor as a support.type keword +*/ + +interface NewInterface{ + currentData: Data; + setVal(d: Data) +} + + +class NewClass implements NewInterface { + currentData: Data; + setVal(d: Data){ + this.currentData = d; + } + constructor(m: number, n: string){} +} + +/* + Testing comments +*/ +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/* + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +> Testing Isuue 32: Adding constructor as a support.type keword + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts +>*/ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +> + ^ + source.ts +>interface NewInterface{ + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^^^^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> currentData: Data; + ^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +> setVal(d: Data) + ^ + source.ts meta.interface.ts meta.method.declaration.ts + ^^^^^^ + source.ts meta.interface.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> + ^ + source.ts +> + ^ + source.ts +>class NewClass implements NewInterface { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^^^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> currentData: Data; + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> setVal(d: Data){ + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> this.currentData = d; + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> constructor(m: number, n: string){} + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>/* + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +> Testing comments + ^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts +>*/ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts \ No newline at end of file diff --git a/tests/baselines/Issue32.txt b/tests/baselines/Issue32.txt deleted file mode 100644 index 8a06873f..00000000 --- a/tests/baselines/Issue32.txt +++ /dev/null @@ -1,14 +0,0 @@ -[5, 1]: source.ts meta.declaration.object.ts storage.type.ts -[5, 11]: source.ts meta.declaration.object.ts meta.object.name.ts entity.name.class.ts -[6, 2]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts variable.ts -[7, 2]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[11, 1]: source.ts meta.declaration.object.ts storage.type.ts -[12, 2]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts variable.ts -[13, 2]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[14, 3]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts constant.language.this.ts -[16, 2]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.type.ts -[16, 14]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[16, 17]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts meta.type.annotation.ts meta.type.primitive.ts support.type.ts -[16, 25]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[16, 28]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts meta.type.annotation.ts meta.type.primitive.ts support.type.ts -[18, 1]: source.ts \ No newline at end of file diff --git a/tests/baselines/Issue321.baseline.txt b/tests/baselines/Issue321.baseline.txt new file mode 100644 index 00000000..6933a545 --- /dev/null +++ b/tests/baselines/Issue321.baseline.txt @@ -0,0 +1,1088 @@ +original file +----------------------------------- +export abstract class ExpressionContainer implements debug.IExpressionContainer { + public getChildren(debugService: debug.IDebugService): TPromise { + if (!this.cacheChildren || !this.children) { + const session = debugService.activeSession; + // only variables with reference > 0 have children. + if (!session || this.reference <= 0) { + this.children = TPromise.as([]); + } else { + + // Check if object has named variables, fetch them independent from indexed variables #9670 + this.children = (!!this.namedVariables ? this.fetchVariables(session, undefined, undefined, 'named') : TPromise.as([])).then(childrenArray => { + // Use a dynamic chunk size based on the number of elements #9774 + let chunkSize = ExpressionContainer.BASE_CHUNK_SIZE; + while (this.indexedVariables > chunkSize * ExpressionContainer.BASE_CHUNK_SIZE) { + chunkSize *= ExpressionContainer.BASE_CHUNK_SIZE; + } + + if (this.indexedVariables > chunkSize) { + // There are a lot of children, create fake intermediate values that represent chunks #9537 + const numberOfChunks = Math.ceil(this.indexedVariables / chunkSize); + for (let i = 0; i < numberOfChunks; i++) { + const start = this.startOfVariables + i * chunkSize; + const count = Math.min(chunkSize, this.indexedVariables - i * chunkSize); + childrenArray.push(new Variable(this, this.reference, `[${start}..${start + count - 1}]`, '', null, count, null, true, start)); + } + + return childrenArray; + } + + const start = this.getChildrenInChunks ? this.startOfVariables : undefined; + const count = this.getChildrenInChunks ? this.indexedVariables : undefined; + return this.fetchVariables(session, start, count, 'indexed') + .then(variables => arrays.distinct(childrenArray.concat(variables), child => child.name)); + }); + } + } + + return this.children; + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export abstract class ExpressionContainer implements debug.IExpressionContainer { + ^^^^^^ + source.ts meta.class.ts keyword.control.export.ts + ^ + source.ts meta.class.ts + ^^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts entity.name.type.module.ts + ^ + source.ts meta.class.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> public getChildren(debugService: debug.IDebugService): TPromise { + ^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.module.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts punctuation.accessor.ts + ^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.parameters.ts entity.name.type.module.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.parameters.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.parameters.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.parameters.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> if (!this.cacheChildren || !this.children) { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.logical.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.logical.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> const session = debugService.activeSession; + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> // only variables with reference > 0 have children. + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts comment.line.double-slash.ts +> if (!session || this.reference <= 0) { + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts keyword.operator.logical.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> this.children = TPromise.as([]); + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } else { + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts +> // Check if object has named variables, fetch them independent from indexed variables #9670 + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts comment.line.double-slash.ts +> this.children = (!!this.namedVariables ? this.fetchVariables(session, undefined, undefined, 'named') : TPromise.as([])).then(childrenArray => { + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts keyword.operator.logical.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts constant.language.undefined.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts constant.language.undefined.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.promise.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> // Use a dynamic chunk size based on the number of elements #9774 + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts comment.line.double-slash.ts +> let chunkSize = ExpressionContainer.BASE_CHUNK_SIZE; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> while (this.indexedVariables > chunkSize * ExpressionContainer.BASE_CHUNK_SIZE) { + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts keyword.control.loop.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> chunkSize *= ExpressionContainer.BASE_CHUNK_SIZE; + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts keyword.operator.assignment.compound.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts variable.other.constant.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts +> if (this.indexedVariables > chunkSize) { + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> // There are a lot of children, create fake intermediate values that represent chunks #9537 + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts comment.line.double-slash.ts +> const numberOfChunks = Math.ceil(this.indexedVariables / chunkSize); + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.function-call.ts support.constant.math.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.function-call.ts support.function.math.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> for (let i = 0; i < numberOfChunks; i++) { + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts keyword.control.loop.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts keyword.operator.increment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> const start = this.startOfVariables + i * chunkSize; + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> const count = Math.min(chunkSize, this.indexedVariables - i * chunkSize); + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.function-call.ts support.constant.math.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.function-call.ts support.function.math.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> childrenArray.push(new Variable(this, this.reference, `[${start}..${start + count - 1}]`, '', null, count, null, true, start)); + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts + ^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts punctuation.definition.string.template.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts constant.language.null.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts constant.language.null.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts constant.language.boolean.true.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts +> return childrenArray; + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts +> const start = this.getChildrenInChunks ? this.startOfVariables : undefined; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts constant.language.undefined.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> const count = this.getChildrenInChunks ? this.indexedVariables : undefined; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.var.expr.ts constant.language.undefined.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> return this.fetchVariables(session, start, count, 'indexed') + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts +> .then(variables => arrays.distinct(childrenArray.concat(variables), child => child.name)); + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts support.function.promise.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.arrow.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.arrow.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.arrow.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.arrow.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> }); + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts +> return this.children; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue322.baseline.txt b/tests/baselines/Issue322.baseline.txt new file mode 100644 index 00000000..fd29733d --- /dev/null +++ b/tests/baselines/Issue322.baseline.txt @@ -0,0 +1,200 @@ +original file +----------------------------------- +export enum TokenType { + StartCommentTag, + Comment, + EndCommentTag, + StartTagOpen, + StartTagClose, + StartTagSelfClose, + StartTag, + EndTagOpen, + EndTagClose, + EndTag, + DelimiterAssign, + AttributeName, + AttributeValue, + StartDoctypeTag, + Doctype, + EndDoctypeTag, + Content, + Whitespace, + Unknown, + Script, + Styles, + EOS +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export enum TokenType { + ^^^^^^ + source.ts meta.enum.declaration.ts keyword.control.export.ts + ^ + source.ts meta.enum.declaration.ts + ^^^^ + source.ts meta.enum.declaration.ts storage.type.enum.ts + ^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^ + source.ts meta.enum.declaration.ts entity.name.type.enum.ts + ^ + source.ts meta.enum.declaration.ts + ^ + source.ts meta.enum.declaration.ts punctuation.definition.block.ts +> StartCommentTag, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> Comment, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> EndCommentTag, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> StartTagOpen, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> StartTagClose, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> StartTagSelfClose, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> StartTag, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> EndTagOpen, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> EndTagClose, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> EndTag, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> DelimiterAssign, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> AttributeName, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> AttributeValue, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> StartDoctypeTag, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> Doctype, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> EndDoctypeTag, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> Content, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> Whitespace, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> Unknown, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> Script, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> Styles, + ^^^^ + source.ts meta.enum.declaration.ts + ^^^^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts + ^ + source.ts meta.enum.declaration.ts punctuation.separator.comma.ts +> EOS + ^^^^ + source.ts meta.enum.declaration.ts + ^^^ + source.ts meta.enum.declaration.ts variable.other.enummember.ts +>} + ^ + source.ts meta.enum.declaration.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue326.baseline.txt b/tests/baselines/Issue326.baseline.txt new file mode 100644 index 00000000..3e33a274 --- /dev/null +++ b/tests/baselines/Issue326.baseline.txt @@ -0,0 +1,38 @@ +original file +----------------------------------- +class Bar extends getFoo("baz") {} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Bar extends getFoo("baz") {} + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.brace.round.ts + ^ + source.ts meta.class.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.class.ts string.quoted.double.ts + ^ + source.ts meta.class.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.brace.round.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue334.baseline.txt b/tests/baselines/Issue334.baseline.txt new file mode 100644 index 00000000..0af86af5 --- /dev/null +++ b/tests/baselines/Issue334.baseline.txt @@ -0,0 +1,350 @@ +original file +----------------------------------- +var Backbone= require("backbone"); +var SearchModel= require("./../search/models/SearchModel"); +var ResultsContainerModel= require("./ResultsContainerModel"); + +var _PROP_SEARCH_ = "SEARCH"; +var _PROP_RESULTS_CONTAINER_ = "SERCH_RESULTS"; + +var PageModel= Backbone.Model.extend({ + + defaults: function() { + var defaults= {}; + defaults[_PROP_SEARCH_]= new SearchModel(); + defaults[_PROP_RESULTS_CONTAINER_]= new ResultsContainerModel(); + return defaults; + }, + +}, { + propSearch: _PROP_SEARCH_, + propResultsContainer: _PROP_RESULTS_CONTAINER_ +}); + +module.exports= PageModel; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>var Backbone= require("backbone"); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>var SearchModel= require("./../search/models/SearchModel"); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>var ResultsContainerModel= require("./ResultsContainerModel"); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>var _PROP_SEARCH_ = "SEARCH"; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>var _PROP_RESULTS_CONTAINER_ = "SERCH_RESULTS"; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>var PageModel= Backbone.Model.extend({ + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts +> defaults: function() { + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> var defaults= {}; + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> defaults[_PROP_SEARCH_]= new SearchModel(); + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts new.expr.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> defaults[_PROP_RESULTS_CONTAINER_]= new ResultsContainerModel(); + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts new.expr.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> return defaults; + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> }, + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts +>}, { + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> propSearch: _PROP_SEARCH_, + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> propResultsContainer: _PROP_RESULTS_CONTAINER_ + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts +>}); + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>module.exports= PageModel; + ^^^^^^ + source.ts support.type.object.module.ts + ^ + source.ts punctuation.accessor.ts + ^^^^^^^ + source.ts support.type.object.module.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue335.baseline.txt b/tests/baselines/Issue335.baseline.txt new file mode 100644 index 00000000..53852273 --- /dev/null +++ b/tests/baselines/Issue335.baseline.txt @@ -0,0 +1,544 @@ +original file +----------------------------------- +class A1 { + b() { + let d; + d.default = 1; + } + + private static c() { + } +} + +class A2 { + b() { + let d; + d.case = 1 + } + + private static c() { + } +} + +class A3 { + b() { + let d + d.default = 1 + switch (d.default) { + case 1: + case 2: + default: + break; + } + } + + private static c() { + } +} + +class A4 { + b() { + let d + d.case = 1 + switch (d.default) { + case 1: + case 2: + default: + break; + } + } + + private static c() { + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class A1 { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> b() { + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> let d; + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> d.default = 1; + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> private static c() { + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> } + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>class A2 { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> b() { + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> let d; + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> d.case = 1 + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts +> } + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> private static c() { + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> } + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>class A3 { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> b() { + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> let d + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts +> d.default = 1 + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts +> switch (d.default) { + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts keyword.control.switch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.definition.block.ts +> case 1: + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> case 2: + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> default: + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> break; + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> } + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts punctuation.definition.block.ts +> } + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> private static c() { + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> } + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>class A4 { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> b() { + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> let d + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts +> d.case = 1 + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts +> switch (d.default) { + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts keyword.control.switch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.definition.block.ts +> case 1: + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> case 2: + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> default: + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts +> break; + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> } + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts switch-statement.expr.ts punctuation.definition.block.ts +> } + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> private static c() { + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> } + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue335.txt b/tests/baselines/Issue335.txt deleted file mode 100644 index 3461b3d6..00000000 --- a/tests/baselines/Issue335.txt +++ /dev/null @@ -1,20 +0,0 @@ -[4, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts -[7, 2]: source.ts meta.declaration.object.ts meta.object.body.ts storage.modifier.ts -[7, 10]: source.ts meta.declaration.object.ts meta.object.body.ts keyword.other.ts -[14, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts -[17, 2]: source.ts meta.declaration.object.ts meta.object.body.ts storage.modifier.ts -[17, 10]: source.ts meta.declaration.object.ts meta.object.body.ts keyword.other.ts -[24, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts -[25, 13]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts switch-statement.expr.ts switch-expression.expr.ts -[26, 4]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.ts -[27, 4]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.ts -[28, 4]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.ts -[33, 2]: source.ts meta.declaration.object.ts meta.object.body.ts storage.modifier.ts -[33, 10]: source.ts meta.declaration.object.ts meta.object.body.ts keyword.other.ts -[40, 5]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts -[41, 13]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts switch-statement.expr.ts switch-expression.expr.ts -[42, 4]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.ts -[43, 4]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.ts -[44, 4]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.ts -[49, 2]: source.ts meta.declaration.object.ts meta.object.body.ts storage.modifier.ts -[49, 10]: source.ts meta.declaration.object.ts meta.object.body.ts keyword.other.ts diff --git a/tests/baselines/Issue337.baseline.txt b/tests/baselines/Issue337.baseline.txt new file mode 100644 index 00000000..6d485039 --- /dev/null +++ b/tests/baselines/Issue337.baseline.txt @@ -0,0 +1,12 @@ +original file +----------------------------------- +#!/usr/bin/env node -r babel-register +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>#!/usr/bin/env node -r babel-register + ^^ + source.ts comment.line.shebang.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.shebang.ts \ No newline at end of file diff --git a/tests/baselines/Issue338.baseline.txt b/tests/baselines/Issue338.baseline.txt new file mode 100644 index 00000000..81d9116b --- /dev/null +++ b/tests/baselines/Issue338.baseline.txt @@ -0,0 +1,92 @@ +original file +----------------------------------- +let a = { + [['a', 'b', 'c'].join(' ')]: 'foo', +}; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let a = { + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> [['a', 'b', 'c'].join(' ')]: 'foo', + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +>}; + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue339.baseline.txt b/tests/baselines/Issue339.baseline.txt new file mode 100644 index 00000000..c917abd1 --- /dev/null +++ b/tests/baselines/Issue339.baseline.txt @@ -0,0 +1,330 @@ +original file +----------------------------------- +function f() { + + class implements BeingSpreading { + copy = copy; + fuse = fuse; + toInternalSpreading = toInternalSpreading; + toFiltersOnlySpreading = toFiltersOnlySpreading; + toResultsOnlySpreading = toResultsOnlySpreading; + toNormalSpreading = toNormalSpreading; + toNormalOrMaximizedSpreadingIfNotYet = ensureNormalOrMaximizedSpreading; + }; + + return new class implements BeingSpreading { + copy = copy; + fuse = fuse; + toInternalSpreading = toInternalSpreading; + toFiltersOnlySpreading = toFiltersOnlySpreading; + toResultsOnlySpreading = toResultsOnlySpreading; + toNormalSpreading = toNormalSpreading; + toNormalOrMaximizedSpreadingIfNotYet = ensureNormalOrMaximizedSpreading; + }; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function f() { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.function.ts meta.block.ts +> class implements BeingSpreading { + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts + ^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts punctuation.definition.block.ts +> copy = copy; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts punctuation.terminator.statement.ts +> fuse = fuse; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts punctuation.terminator.statement.ts +> toInternalSpreading = toInternalSpreading; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts punctuation.terminator.statement.ts +> toFiltersOnlySpreading = toFiltersOnlySpreading; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts punctuation.terminator.statement.ts +> toResultsOnlySpreading = toResultsOnlySpreading; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts punctuation.terminator.statement.ts +> toNormalSpreading = toNormalSpreading; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts punctuation.terminator.statement.ts +> toNormalOrMaximizedSpreadingIfNotYet = ensureNormalOrMaximizedSpreading; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts punctuation.terminator.statement.ts +> }; + ^^^^ + source.ts meta.function.ts meta.block.ts meta.class.ts + ^ + source.ts meta.function.ts meta.block.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.function.ts meta.block.ts +> return new class implements BeingSpreading { + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts + ^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts punctuation.definition.block.ts +> copy = copy; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts punctuation.terminator.statement.ts +> fuse = fuse; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts punctuation.terminator.statement.ts +> toInternalSpreading = toInternalSpreading; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts punctuation.terminator.statement.ts +> toFiltersOnlySpreading = toFiltersOnlySpreading; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts punctuation.terminator.statement.ts +> toResultsOnlySpreading = toResultsOnlySpreading; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts punctuation.terminator.statement.ts +> toNormalSpreading = toNormalSpreading; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts punctuation.terminator.statement.ts +> toNormalOrMaximizedSpreadingIfNotYet = ensureNormalOrMaximizedSpreading; + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts meta.field.declaration.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts punctuation.terminator.statement.ts +> }; + ^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue343.baseline.txt b/tests/baselines/Issue343.baseline.txt new file mode 100644 index 00000000..b81eeb8f --- /dev/null +++ b/tests/baselines/Issue343.baseline.txt @@ -0,0 +1,90 @@ +original file +----------------------------------- +console.log(`${Math.round(responseTime / requests)} ns (${Math.round(requests / ( responseTime / 1e9))}/sec)`); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>console.log(`${Math.round(responseTime / requests)} ns (${Math.round(requests / ( responseTime / 1e9))}/sec)`); + ^^^^^^^ + source.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^ + source.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts support.constant.math.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts support.function.math.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.brace.round.ts + ^^^^^^^^^^^^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts keyword.operator.arithmetic.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts + ^^^^^^^^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.brace.round.ts + ^ + source.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^^^^ + source.ts string.template.ts + ^^ + source.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts support.constant.math.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts support.function.math.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.brace.round.ts + ^^^^^^^^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts keyword.operator.arithmetic.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.brace.round.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts + ^^^^^^^^^^^^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts keyword.operator.arithmetic.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts + ^^^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts constant.numeric.decimal.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.brace.round.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.brace.round.ts + ^ + source.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^^^^ + source.ts string.template.ts + ^ + source.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue344.baseline.txt b/tests/baselines/Issue344.baseline.txt new file mode 100644 index 00000000..6d938330 --- /dev/null +++ b/tests/baselines/Issue344.baseline.txt @@ -0,0 +1,102 @@ +original file +----------------------------------- +let a = Array(); // Highlight ok here + +interface egGenericsInArray { + a: Array; +} +let s = "nothing should fail here..."; +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>let a = Array(); // Highlight ok here + ^^^ + source.tsx meta.var.expr.tsx storage.type.tsx + ^ + source.tsx meta.var.expr.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.definition.variable.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx + ^ + source.tsx meta.var.expr.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx + ^^^^^ + source.tsx meta.var.expr.tsx meta.function-call.tsx support.class.builtin.tsx + ^ + source.tsx meta.var.expr.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.type.parameters.tsx support.type.primitive.tsx + ^ + source.tsx meta.var.expr.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.brace.round.tsx + ^ + source.tsx meta.var.expr.tsx meta.brace.round.tsx + ^ + source.tsx punctuation.terminator.statement.tsx + ^^^ + source.tsx + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^^^^^^^^^^^^^ + source.tsx comment.line.double-slash.tsx +> + ^ + source.tsx +>interface egGenericsInArray { + ^^^^^^^^^ + source.tsx meta.interface.tsx storage.type.interface.tsx + ^ + source.tsx meta.interface.tsx + ^^^^^^^^^^^^^^^^^ + source.tsx meta.interface.tsx entity.name.type.interface.tsx + ^ + source.tsx meta.interface.tsx + ^ + source.tsx meta.interface.tsx punctuation.definition.block.tsx +> a: Array; + ^^^ + source.tsx meta.interface.tsx meta.field.declaration.tsx + ^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.definition.property.tsx variable.object.property.tsx + ^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx + ^^^^^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx entity.name.type.tsx + ^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + ^^^^^^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx meta.type.parameters.tsx support.type.primitive.tsx + ^ + source.tsx meta.interface.tsx meta.field.declaration.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + ^ + source.tsx meta.interface.tsx punctuation.terminator.statement.tsx +>} + ^ + source.tsx meta.interface.tsx punctuation.definition.block.tsx +>let s = "nothing should fail here..."; + ^^^ + source.tsx meta.var.expr.tsx storage.type.tsx + ^ + source.tsx meta.var.expr.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.definition.variable.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx + ^ + source.tsx meta.var.expr.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx + ^ + source.tsx meta.var.expr.tsx string.quoted.double.tsx punctuation.definition.string.begin.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.var.expr.tsx string.quoted.double.tsx + ^ + source.tsx meta.var.expr.tsx string.quoted.double.tsx punctuation.definition.string.end.tsx + ^ + source.tsx punctuation.terminator.statement.tsx \ No newline at end of file diff --git a/tests/baselines/Issue346.baseline.txt b/tests/baselines/Issue346.baseline.txt new file mode 100644 index 00000000..b8e74d2c --- /dev/null +++ b/tests/baselines/Issue346.baseline.txt @@ -0,0 +1,666 @@ +original file +----------------------------------- +function f() +{ + let t = 0 + let TAU440 = Math.PI*2 * 440 + + onmessage = function(e) + { + let b = new Float64Array(e.data.bufferSize) + let s = e.data.sampleRate + + for (let i = 0; i < b.length; i++) b[i] = Math.sin(TAU440 * t++/s * Math.sin(t++/s*.5)) + + postMessage(b) + } +} + +let a = new AudioContext() +let s = a.createScriptProcessor(0,1,1) +let b = new Float64Array(s.bufferSize) +let w = new Worker(URL.createObjectURL(new Blob(["("+f+"())"],{type:"application/javascript"}))) + +w.onmessage = e => b = e.data +s.connect(a.destination) + +s.onaudioprocess = function(e) +{ + w.postMessage({ bufferSize: s.bufferSize, sampleRate: a.sampleRate }) + e.outputBuffer.getChannelData(0).set(b) +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function f() + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>{ + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> let t = 0 + ^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts +> let TAU440 = Math.PI*2 * 440 + ^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts support.constant.math.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts support.constant.property.math.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts +> + ^ + source.ts meta.function.ts meta.block.ts +> onmessage = function(e) + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^^^^ + source.ts meta.function.ts meta.block.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts +> { + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> let b = new Float64Array(e.data.bufferSize) + ^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts new.expr.ts + ^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts new.expr.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts new.expr.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts new.expr.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts new.expr.ts support.variable.property.dom.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts new.expr.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts new.expr.ts variable.other.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts +> let s = e.data.sampleRate + ^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts support.variable.property.dom.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts variable.other.property.ts +> + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts +> for (let i = 0; i < b.length; i++) b[i] = Math.sin(TAU440 * t++/s * Math.sin(t++/s*.5)) + ^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts keyword.control.loop.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts support.variable.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts keyword.operator.increment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.function-call.ts support.constant.math.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.math.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts variable.other.constant.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts keyword.operator.increment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.function-call.ts support.constant.math.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.math.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts keyword.operator.increment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.brace.round.ts +> + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts +> postMessage(b) + ^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts meta.brace.round.ts +> } + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>let a = new AudioContext() + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts support.class.dom.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts +>let s = a.createScriptProcessor(0,1,1) + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts +>let b = new Float64Array(s.bufferSize) + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts new.expr.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts variable.other.property.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts +>let w = new Worker(URL.createObjectURL(new Blob(["("+f+"())"],{type:"application/javascript"}))) + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts support.class.dom.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts variable.other.constant.object.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts + ^^^^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.function-call.ts support.class.dom.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.array.literal.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.array.literal.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^^^^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts new.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts +> + ^ + source.ts +>w.onmessage = e => b = e.data + ^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts entity.name.function.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts meta.arrow.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^^^ + source.ts support.variable.property.dom.ts +>s.connect(a.destination) + ^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts variable.other.property.ts + ^ + source.ts meta.brace.round.ts +> + ^ + source.ts +>s.onaudioprocess = function(e) + ^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^ + source.ts entity.name.function.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>{ + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> w.postMessage({ bufferSize: s.bufferSize, sampleRate: a.sampleRate }) + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts +> e.outputBuffer.getChannelData(0).set(b) + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue347.baseline.txt b/tests/baselines/Issue347.baseline.txt new file mode 100644 index 00000000..deb2f3e1 --- /dev/null +++ b/tests/baselines/Issue347.baseline.txt @@ -0,0 +1,180 @@ +original file +----------------------------------- +const a = new Promise (resolve => { + const file = this.props.doc.file; + resolve({ + abc: Math.random() + }); + + class Foo extends React.Component { + render() { + } + } + +}); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const a = new Promise (resolve => { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts support.class.promise.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts + ^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> const file = this.props.doc.file; + ^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.language.this.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.object.property.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.object.property.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> resolve({ + ^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts + ^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts +> abc: Math.random() + ^^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.objectliteral.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts support.constant.math.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts support.function.math.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts +> }); + ^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts +> class Foo extends React.Component { + ^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts + ^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts + ^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts entity.name.type.module.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts punctuation.definition.block.ts +> render() { + ^^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts meta.method.declaration.ts + ^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts meta.class.ts punctuation.definition.block.ts +> + ^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts +>}); + ^ + source.ts meta.var.expr.ts new.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue351.baseline.txt b/tests/baselines/Issue351.baseline.txt new file mode 100644 index 00000000..0195bc89 --- /dev/null +++ b/tests/baselines/Issue351.baseline.txt @@ -0,0 +1,58 @@ +original file +----------------------------------- +this._blockRenderMap = Map({}); +this._eventsMap = {}; +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>this._blockRenderMap = Map({}); + ^^^^ + source.tsx variable.language.this.tsx + ^ + source.tsx punctuation.accessor.tsx + ^^^^^^^^^^^^^^^ + source.tsx variable.other.property.tsx + ^ + source.tsx + ^ + source.tsx keyword.operator.assignment.tsx + ^ + source.tsx + ^^^ + source.tsx meta.function-call.tsx support.class.builtin.tsx + ^ + source.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + ^^^ + source.tsx meta.type.parameters.tsx support.type.primitive.tsx + ^ + source.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx meta.objectliteral.tsx punctuation.definition.block.tsx + ^ + source.tsx meta.objectliteral.tsx punctuation.definition.block.tsx + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +>this._eventsMap = {}; + ^^^^ + source.tsx variable.language.this.tsx + ^ + source.tsx punctuation.accessor.tsx + ^^^^^^^^^^ + source.tsx variable.other.property.tsx + ^ + source.tsx + ^ + source.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.objectliteral.tsx + ^ + source.tsx meta.objectliteral.tsx punctuation.definition.block.tsx + ^ + source.tsx meta.objectliteral.tsx punctuation.definition.block.tsx + ^ + source.tsx punctuation.terminator.statement.tsx \ No newline at end of file diff --git a/tests/baselines/Issue356.baseline.txt b/tests/baselines/Issue356.baseline.txt new file mode 100644 index 00000000..322f531c --- /dev/null +++ b/tests/baselines/Issue356.baseline.txt @@ -0,0 +1,204 @@ +original file +----------------------------------- +function formatBigNum(num) { + num = Number(num) + if (num < 10000) { + return num + } + return (num/10000).toString().replace(/(\.[\d]{1})\d+$/,"$1") + 'w ' +} +let hbAnimIndex = 0; +let hbAnimNode = null; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function formatBigNum(num) { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> num = Number(num) + ^^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts +> if (num < 10000) { + ^^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> return num + ^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts variable.other.readwrite.ts +> } + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> return (num/10000).toString().replace(/(\.[\d]{1})\d+$/,"$1") + 'w ' + ^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.arithmetic.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts string.regexp.ts meta.group.regexp punctuation.definition.group.regexp + ^^ + source.ts meta.function.ts meta.block.ts string.regexp.ts meta.group.regexp constant.character.escape.backslash.regexp + ^ + source.ts meta.function.ts meta.block.ts string.regexp.ts meta.group.regexp constant.other.character-class.set.regexp punctuation.definition.character-class.regexp + ^^ + source.ts meta.function.ts meta.block.ts string.regexp.ts meta.group.regexp constant.other.character-class.set.regexp constant.other.character-class.regexp + ^ + source.ts meta.function.ts meta.block.ts string.regexp.ts meta.group.regexp constant.other.character-class.set.regexp punctuation.definition.character-class.regexp + ^^^ + source.ts meta.function.ts meta.block.ts string.regexp.ts meta.group.regexp keyword.operator.quantifier.regexp + ^ + source.ts meta.function.ts meta.block.ts string.regexp.ts meta.group.regexp punctuation.definition.group.regexp + ^^ + source.ts meta.function.ts meta.block.ts string.regexp.ts constant.other.character-class.regexp + ^ + source.ts meta.function.ts meta.block.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts meta.function.ts meta.block.ts string.regexp.ts keyword.control.anchor.regexp + ^ + source.ts meta.function.ts meta.block.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.function.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>let hbAnimIndex = 0; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +>let hbAnimNode = null; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.language.null.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue357.baseline.txt b/tests/baselines/Issue357.baseline.txt new file mode 100644 index 00000000..910edb63 --- /dev/null +++ b/tests/baselines/Issue357.baseline.txt @@ -0,0 +1,358 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has jsx +const ProductPrice = ({inStock, price}) => { + const dashCode = 8211 + const dash = String.fromCharCode(dashCode) + return ( + + + {inStock + ? I18n.toCurrency(price) + :
+ {`${dash}`}{I18n.t('spree.out_of_stock')}{`${dash}`} +
} + + + ) +} +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has jsx + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx comment.line.double-slash.tsx +>const ProductPrice = ({inStock, price}) => { + ^^^^^ + source.tsx meta.var.expr.tsx storage.type.tsx + ^ + source.tsx meta.var.expr.tsx + ^^^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.definition.variable.tsx variable.other.constant.tsx entity.name.function.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx + ^ + source.tsx meta.var.expr.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.parameter.object-binding-pattern.tsx punctuation.definition.binding-pattern.object.tsx + ^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.parameter.object-binding-pattern.tsx variable.parameter.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.parameter.object-binding-pattern.tsx punctuation.separator.comma.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.parameter.object-binding-pattern.tsx + ^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.parameter.object-binding-pattern.tsx variable.parameter.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.parameter.object-binding-pattern.tsx punctuation.definition.binding-pattern.object.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx storage.type.function.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx punctuation.definition.block.tsx +> const dashCode = 8211 + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx storage.type.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx + ^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.definition.variable.tsx variable.other.constant.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx + ^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx constant.numeric.decimal.tsx +> const dash = String.fromCharCode(dashCode) + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx storage.type.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx + ^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.definition.variable.tsx variable.other.constant.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx meta.function-call.tsx support.class.builtin.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx meta.function-call.tsx support.function.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx meta.brace.round.tsx + ^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.var.expr.tsx meta.brace.round.tsx +> return ( + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx keyword.control.flow.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.brace.round.tsx +> className={styles.uPrice} + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx punctuation.section.embedded.begin.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.object.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.property.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx punctuation.section.embedded.end.tsx +> itemProp='offers' + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx +> itemScope='' + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx +> itemType='https://schema.org/Offer' + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx +> > + ^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx punctuation.definition.tag.end.tsx +> itemProp='price' + ^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx +> > + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.tag.attributes.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx +> {inStock + ^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.begin.tsx + ^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx variable.other.readwrite.tsx +> ? I18n.toCurrency(price) + ^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx keyword.operator.ternary.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx + ^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx variable.other.object.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx entity.name.function.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.brace.round.tsx + ^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.brace.round.tsx +> :
+ ^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx keyword.operator.ternary.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.tag.attributes.tsx punctuation.section.embedded.begin.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.object.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.property.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.tag.attributes.tsx punctuation.section.embedded.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx punctuation.definition.tag.end.tsx +> {`${dash}`}{I18n.t('spree.out_of_stock')}{`${dash}`} + ^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.begin.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx string.template.tsx punctuation.definition.string.template.begin.tsx + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx string.template.tsx meta.template.expression.tsx punctuation.definition.template-expression.begin.tsx + ^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx string.template.tsx meta.template.expression.tsx meta.embedded.line.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx string.template.tsx meta.template.expression.tsx punctuation.definition.template-expression.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx string.template.tsx punctuation.definition.string.template.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.begin.tsx + ^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx variable.other.object.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx punctuation.accessor.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx entity.name.function.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.brace.round.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^^^^^^^^^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx string.quoted.single.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.brace.round.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.begin.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx string.template.tsx punctuation.definition.string.template.begin.tsx + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx string.template.tsx meta.template.expression.tsx punctuation.definition.template-expression.begin.tsx + ^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx string.template.tsx meta.template.expression.tsx meta.embedded.line.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx string.template.tsx meta.template.expression.tsx punctuation.definition.template-expression.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx string.template.tsx punctuation.definition.string.template.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.end.tsx +>
} + ^^^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.end.tsx +> + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.tag.tsx punctuation.definition.tag.end.tsx +> + ^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.tag.tsx punctuation.definition.tag.end.tsx +> ) + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx meta.brace.round.tsx +>} + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.block.tsx punctuation.definition.block.tsx \ No newline at end of file diff --git a/tests/baselines/Issue359.baseline.txt b/tests/baselines/Issue359.baseline.txt new file mode 100644 index 00000000..728f9464 --- /dev/null +++ b/tests/baselines/Issue359.baseline.txt @@ -0,0 +1,150 @@ +original file +----------------------------------- +const test = (value: string) => { + const a = 123; + const b = { + [`${value}[]`]: a, + }; + const c = 123; + return b; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const test = (value: string) => { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> const a = 123; + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> const b = { + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> [`${value}[]`]: a, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.template.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> }; + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> const c = 123; + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> return b; + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue36.baseline.txt b/tests/baselines/Issue36.baseline.txt new file mode 100644 index 00000000..ccc31b4f --- /dev/null +++ b/tests/baselines/Issue36.baseline.txt @@ -0,0 +1,72 @@ +original file +----------------------------------- +let x = { + hello() { + let hello = "world"; + } +}; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let x = { + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> hello() { + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> let hello = "world"; + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>}; + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue361.baseline.txt b/tests/baselines/Issue361.baseline.txt new file mode 100644 index 00000000..a70ed7c9 --- /dev/null +++ b/tests/baselines/Issue361.baseline.txt @@ -0,0 +1,60 @@ +original file +----------------------------------- +const constructor = someObject.prototype.constructor; + const objectLiteral = { constructor }; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const constructor = someObject.prototype.constructor; + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts support.class.ts + ^ + source.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts support.variable.property.ts + ^ + source.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts support.variable.property.ts + ^ + source.ts punctuation.terminator.statement.ts +> const objectLiteral = { constructor }; + ^ + source.ts + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue365.baseline.txt b/tests/baselines/Issue365.baseline.txt new file mode 100644 index 00000000..3a9a3262 --- /dev/null +++ b/tests/baselines/Issue365.baseline.txt @@ -0,0 +1,100 @@ +original file +----------------------------------- +class Renamer { + constructor (private readonly srcName: string, private readonly target: string, readonly copy: boolean = false) {} +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Renamer { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> constructor (private readonly srcName: string, private readonly target: string, readonly copy: boolean = false) {} + ^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts constant.language.boolean.false.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue366.baseline.txt b/tests/baselines/Issue366.baseline.txt new file mode 100644 index 00000000..db18a590 --- /dev/null +++ b/tests/baselines/Issue366.baseline.txt @@ -0,0 +1,66 @@ +original file +----------------------------------- +let foo = a ? b ? c : d : e; +let bar; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let foo = a ? b ? c : d : e; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +>let bar; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue368.baseline.txt b/tests/baselines/Issue368.baseline.txt new file mode 100644 index 00000000..026d848f --- /dev/null +++ b/tests/baselines/Issue368.baseline.txt @@ -0,0 +1,106 @@ +original file +----------------------------------- +let creditCard = 'cc'; +const CREDIT_CARD = 'CC'; + +console.log(`Payment Type: ${creditCard}`); +console.log(`Payment Type: ${CREDIT_CARD}`); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let creditCard = 'cc'; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>const CREDIT_CARD = 'CC'; + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>console.log(`Payment Type: ${creditCard}`); + ^^^^^^^ + source.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^^^^^^^^^^^^^ + source.ts string.template.ts + ^^ + source.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^^^^^^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^ + source.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>console.log(`Payment Type: ${CREDIT_CARD}`); + ^^^^^^^ + source.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^^^^^^^^^^^^^ + source.ts string.template.ts + ^^ + source.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^^^^^^^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.constant.ts + ^ + source.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^ + source.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue37.baseline.txt b/tests/baselines/Issue37.baseline.txt new file mode 100644 index 00000000..221be9dc --- /dev/null +++ b/tests/baselines/Issue37.baseline.txt @@ -0,0 +1,776 @@ +original file +----------------------------------- +//Test For Scopes + +import * as req from "./Required" +import { Scale } from "./scale"; + +if (object.instanceof(ClassNew)) { +} + +class class1(){ + static functioname(){ + + } +} + +export class className(){ + private state = { } +} + +void newFunctionName(){ + + var c = a + b; + + switch (someNum) { + case 1: break; + case 2: break; + default: break; + } + +} + +/** + * Verify comments + */ + +module M { + export function myFun(x: number) { + return x; + } +} + +var m: typeof M = M; + +var adder = new Adder(3, 4); +delete (adder) + +var s = typeof {}git +interface I {} +var j: I = {} + + +module Body { + export class Cell { + public parent: Cell; + + constructor(parent: Cell) { + this.parent = parent; + if (typeof parent === 'object' || parent instanceof Error) { + + } + } + } +} + +/* + + End of file + +*/ +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>//Test For Scopes + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +> + ^ + source.ts +>import * as req from "./Required" + ^^^^^^ + source.ts meta.import.ts keyword.control.import.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts constant.language.import-export-all.ts + ^ + source.ts meta.import.ts + ^^ + source.ts meta.import.ts keyword.control.as.ts + ^ + source.ts meta.import.ts + ^^^ + source.ts meta.import.ts variable.other.readwrite.alias.ts + ^ + source.ts meta.import.ts + ^^^^ + source.ts meta.import.ts keyword.control.from.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^ + source.ts meta.import.ts string.quoted.double.ts + ^ + source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.end.ts +>import { Scale } from "./scale"; + ^^^^^^ + source.ts meta.import.ts keyword.control.import.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.import.ts meta.block.ts + ^^^^^ + source.ts meta.import.ts meta.block.ts variable.other.readwrite.alias.ts + ^ + source.ts meta.import.ts meta.block.ts + ^ + source.ts meta.import.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.import.ts + ^^^^ + source.ts meta.import.ts keyword.control.from.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.import.ts string.quoted.double.ts + ^ + source.ts meta.import.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>if (object.instanceof(ClassNew)) { + ^^ + source.ts keyword.control.conditional.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>class class1(){ + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> static functioname(){ + ^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts +> } + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>export class className(){ + ^^^^^^ + source.ts meta.class.ts keyword.control.export.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> private state = { } + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.objectliteral.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.objectliteral.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>void newFunctionName(){ + ^^^^ + source.ts keyword.operator.expression.void.ts + ^ + source.ts + ^^^^^^^^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.block.ts +> var c = a + b; + ^ + source.ts meta.block.ts + ^^^ + source.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.block.ts +> switch (someNum) { + ^ + source.ts meta.block.ts + ^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.definition.block.ts +> case 1: break; + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> case 2: break; + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> default: break; + ^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.switch.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts punctuation.definition.section.case-statement.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^^^^^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts keyword.control.loop.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts punctuation.terminator.statement.ts +> } + ^ + source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts + ^ + source.ts meta.block.ts switch-statement.expr.ts punctuation.definition.block.ts + ^^ + source.ts meta.block.ts +> + ^ + source.ts meta.block.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>/** + ^^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +> * Verify comments + ^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> */ + ^ + source.ts comment.block.documentation.ts + ^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +> + ^ + source.ts +>module M { + ^^^^^^ + source.ts meta.namespace.declaration.ts storage.type.namespace.ts + ^ + source.ts meta.namespace.declaration.ts + ^ + source.ts meta.namespace.declaration.ts entity.name.type.module.ts + ^ + source.ts meta.namespace.declaration.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts +> export function myFun(x: number) { + ^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts + ^^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts + ^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> return x; + ^^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.block.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.block.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>var m: typeof M = M; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.expression.typeof.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.constant.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>var adder = new Adder(3, 4); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^ + source.ts meta.var.expr.ts new.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>delete (adder) + ^^^^^^ + source.ts keyword.operator.expression.delete.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts +> + ^ + source.ts +>var s = typeof {}git + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts keyword.operator.expression.typeof.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^^^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts +>interface I {} + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +>var j: I = {} + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> + ^ + source.ts +> + ^ + source.ts +>module Body { + ^^^^^^ + source.ts meta.namespace.declaration.ts storage.type.namespace.ts + ^ + source.ts meta.namespace.declaration.ts + ^^^^ + source.ts meta.namespace.declaration.ts entity.name.type.module.ts + ^ + source.ts meta.namespace.declaration.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts +> export class Cell { + ^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts keyword.control.export.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts + ^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts + ^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts punctuation.definition.block.ts +> public parent: Cell; + ^^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.field.declaration.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts +> constructor(parent: Cell) { + ^^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> this.parent = parent; + ^^^^^^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> if (typeof parent === 'object' || parent instanceof Error) { + ^^^^^^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.expression.typeof.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.expression.instanceof.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts entity.name.type.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> + ^^^^^^^^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts +> } + ^^^^^^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.class.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>/* + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +> + ^ + source.ts comment.block.ts +> End of file + ^^^^^^^^^^^^^^ + source.ts comment.block.ts +> + ^ + source.ts comment.block.ts +>*/ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts \ No newline at end of file diff --git a/tests/baselines/Issue37.txt b/tests/baselines/Issue37.txt deleted file mode 100644 index f8b6d422..00000000 --- a/tests/baselines/Issue37.txt +++ /dev/null @@ -1,49 +0,0 @@ -[3, 1]: source.ts keyword.control.import.include.ts -[3, 8]: source.ts keyword.operator.arithmetic.ts -[3, 10]: source.ts keyword.others.ts -[3, 17]: source.ts keyword.control.import.include.ts -[6, 1]: source.ts keyword.control.ts -[6, 12]: source.ts keyword.others.ts -[9, 1]: source.ts meta.declaration.object.ts storage.type.ts -[9, 7]: source.ts meta.declaration.object.ts meta.object.name.ts entity.name.class.ts -[10, 2]: source.ts meta.declaration.object.ts meta.object.body.ts keyword.other.ts -[10, 9]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[15, 1]: source.ts meta.declaration.object.ts storage.type.ts -[15, 8]: source.ts meta.declaration.object.ts storage.type.ts -[16, 2]: source.ts meta.declaration.object.ts meta.object.body.ts storage.modifier.ts -[16, 10]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts variable.ts -[19, 1]: source.ts storage.type.ts -[19, 6]: source.ts -[21, 2]: source.ts meta.block.ts meta.var.expr.ts storage.type.ts -[21, 12]: source.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts keyword.operator.arithmetic.ts -[23, 2]: source.ts meta.block.ts switch-statement.expr.ts switch-expression.expr.ts keyword.control.ts -[24, 3]: source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.ts -[25, 3]: source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.ts -[26, 3]: source.ts meta.block.ts switch-statement.expr.ts switch-block.expr.ts case-clause.expr.ts keyword.control.ts -[35, 1]: source.ts storage.type.ts -[36, 5]: source.ts meta.block.ts meta.function.ts storage.type.ts -[41, 8]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.others.ts -[43, 13]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts new.expr.ts keyword.others.ts -[44, 1]: source.ts keyword.others.ts -[51, 1]: source.ts storage.type.ts -[51, 8]: source.ts -[52, 5]: source.ts meta.block.ts meta.declaration.object.ts storage.type.ts -[52, 12]: source.ts meta.block.ts meta.declaration.object.ts storage.type.ts -[52, 18]: source.ts meta.block.ts meta.declaration.object.ts meta.object.name.ts entity.name.class.ts -[53, 9]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts storage.modifier.ts -[53, 16]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts variable.ts -[53, 24]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts -[55, 9]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts storage.type.ts -[55, 21]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts parameter.name.ts variable.parameter.ts -[55, 29]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.function.type.parameter.ts meta.type.annotation.ts meta.type.name.ts -[56, 13]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts constant.language.this.ts -[56, 27]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts -[57, 17]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.others.ts -[57, 24]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts -[57, 31]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.operator.comparison.ts -[57, 35]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts string.single.ts -[57, 47]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts -[57, 54]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts keyword.others.ts -[57, 65]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts -[58, 14]: source.ts meta.block.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.decl.block.ts meta.block.ts -[65, 1]: source.ts comment.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue375.baseline.txt b/tests/baselines/Issue375.baseline.txt new file mode 100644 index 00000000..5fd90bca --- /dev/null +++ b/tests/baselines/Issue375.baseline.txt @@ -0,0 +1,550 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has type assertion +class Foo { + constructor(public x: string) {} +} + +const foo1 = { x: '1' }; +const foo2 = { + x: '2' +}; +const foo3 = + { + x: '3' + }; + +let foos: Foo[] = [ + new Foo('4'), + { x: '5' }, + { + x: '6' + }, +]; + +let obj = Object.assign(new Foo('7'), { x: '8' }, + { x: '9' }, { x: '10' }, { + x: '11' + }, + { + x: '12' + }); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has type assertion + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>class Foo { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> constructor(public x: string) {} + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>const foo1 = { x: '1' }; + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^ + source.ts meta.var.expr.ts cast.expr.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts +>const foo2 = { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^ + source.ts meta.var.expr.ts cast.expr.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> x: '2' + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts +>}; + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts +>const foo3 = + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts +> { + ^^^^ + source.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^ + source.ts meta.var.expr.ts cast.expr.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> x: '3' + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts +> }; + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>let foos: Foo[] = [ + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^ + source.ts meta.var.expr.ts cast.expr.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts +> new Foo('4'), + ^^^^ + source.ts meta.var.expr.ts meta.array.literal.ts + ^^^ + source.ts meta.var.expr.ts meta.array.literal.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts new.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.array.literal.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts new.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts punctuation.separator.comma.ts +> { x: '5' }, + ^^^^ + source.ts meta.var.expr.ts meta.array.literal.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts cast.expr.ts meta.brace.angle.ts + ^^^ + source.ts meta.var.expr.ts meta.array.literal.ts cast.expr.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts punctuation.separator.comma.ts +> { + ^^^^ + source.ts meta.var.expr.ts meta.array.literal.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts cast.expr.ts meta.brace.angle.ts + ^^^ + source.ts meta.var.expr.ts meta.array.literal.ts cast.expr.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts +> x: '6' + ^^^^^^^^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts +> }, + ^^^^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts punctuation.separator.comma.ts +>]; + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>let obj = Object.assign(new Foo('7'), { x: '8' }, + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts new.expr.ts + ^^^ + source.ts meta.var.expr.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts new.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts new.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^ + source.ts meta.var.expr.ts cast.expr.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts +> { x: '9' }, { x: '10' }, { + ^^^^ + source.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^ + source.ts meta.var.expr.ts cast.expr.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^ + source.ts meta.var.expr.ts cast.expr.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^ + source.ts meta.var.expr.ts cast.expr.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> x: '11' + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts +> }, + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts +> { + ^^^^ + source.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^ + source.ts meta.var.expr.ts cast.expr.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> x: '12' + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts +> }); + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue376.baseline.txt b/tests/baselines/Issue376.baseline.txt new file mode 100644 index 00000000..b8667e01 --- /dev/null +++ b/tests/baselines/Issue376.baseline.txt @@ -0,0 +1,160 @@ +original file +----------------------------------- + interface Itest { + a: 'a1' // a1 is good + | 'a2' // a2 is good + | 'a3' // a3 is good + b: { + a: 'a1' + | 'a2' // oh , the color is not good ! + | 'a3' // oh , the color is not good ! + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +> interface Itest { + ^ + source.ts + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> a: 'a1' // a1 is good + ^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^ + source.ts meta.interface.ts meta.field.declaration.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts comment.line.double-slash.ts +> | 'a2' // a2 is good + ^^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts keyword.operator.bitwise.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.interface.ts string.quoted.single.ts + ^ + source.ts meta.interface.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^ + source.ts meta.interface.ts comment.line.double-slash.ts +> | 'a3' // a3 is good + ^^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts keyword.operator.bitwise.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.interface.ts string.quoted.single.ts + ^ + source.ts meta.interface.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^ + source.ts meta.interface.ts comment.line.double-slash.ts +> b: { + ^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts +> a: 'a1' + ^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.end.ts +> | 'a2' // oh , the color is not good ! + ^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts comment.line.double-slash.ts +> | 'a3' // oh , the color is not good ! + ^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts keyword.operator.type.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts string.quoted.single.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts + ^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts comment.line.double-slash.ts +> } + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue377.baseline.txt b/tests/baselines/Issue377.baseline.txt new file mode 100644 index 00000000..2d922bf3 --- /dev/null +++ b/tests/baselines/Issue377.baseline.txt @@ -0,0 +1,120 @@ +original file +----------------------------------- +dt = ((dt[0] * 1e9 + dt[1]) / 1e6).toFixed(3).replace(/\.?0+$/, '') + 'ms'; + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>dt = ((dt[0] * 1e9 + dt[1]) / 1e6).toFixed(3).replace(/\.?0+$/, '') + 'ms'; + ^^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts + ^^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^^^ + source.ts constant.numeric.decimal.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^^^ + source.ts constant.numeric.decimal.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.regexp.ts punctuation.definition.string.begin.ts + ^^ + source.ts string.regexp.ts constant.character.escape.backslash.regexp + ^ + source.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts string.regexp.ts + ^ + source.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts string.regexp.ts keyword.control.anchor.regexp + ^ + source.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^ + source.ts string.quoted.single.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue379.baseline.txt b/tests/baselines/Issue379.baseline.txt new file mode 100644 index 00000000..e949e29c --- /dev/null +++ b/tests/baselines/Issue379.baseline.txt @@ -0,0 +1,86 @@ +original file +----------------------------------- +interface A { + prop1: string + prop2: string + method1(): void + prop3: string + prop4: string +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>interface A { + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> prop1: string + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts +> prop2: string + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts +> method1(): void + ^^^^ + source.ts meta.interface.ts meta.method.declaration.ts + ^^^^^^^ + source.ts meta.interface.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts + ^^^^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts +> prop3: string + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts +> prop4: string + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue380.baseline.txt b/tests/baselines/Issue380.baseline.txt new file mode 100644 index 00000000..e99db281 --- /dev/null +++ b/tests/baselines/Issue380.baseline.txt @@ -0,0 +1,62 @@ +original file +----------------------------------- +let namespace; +namespace = `${"a"}`; + +let x = 1 +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let namespace; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +>namespace = `${"a"}`; + ^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^ + source.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts string.quoted.double.ts + ^ + source.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^ + source.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>let x = 1 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts \ No newline at end of file diff --git a/tests/baselines/Issue381.baseline.txt b/tests/baselines/Issue381.baseline.txt new file mode 100644 index 00000000..bc757427 --- /dev/null +++ b/tests/baselines/Issue381.baseline.txt @@ -0,0 +1,124 @@ +original file +----------------------------------- +class Foo{ + constructor(){ + + } + test(){ + return `/game.php?village=${source}&screen=main&ajaxaction=upgrade_building&type=main&h=${csrf_token}&&client_time=${+new Date}` + } + noColorSyntax(){ + + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Foo{ + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> constructor(){ + ^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts +> } + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> test(){ + ^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> return `/game.php?village=${source}&screen=main&ajaxaction=upgrade_building&type=main&h=${csrf_token}&&client_time=${+new Date}` + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts keyword.operator.arithmetic.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts new.expr.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts new.expr.ts support.class.builtin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.template.ts punctuation.definition.string.template.end.ts +> } + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> noColorSyntax(){ + ^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts +> } + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue382.baseline.txt b/tests/baselines/Issue382.baseline.txt new file mode 100644 index 00000000..c6492276 --- /dev/null +++ b/tests/baselines/Issue382.baseline.txt @@ -0,0 +1,296 @@ +original file +----------------------------------- + + class ConstrainedBasedObjectcolection + { + public GetState(): { [index : string]: string } + { + if (this.ShouldFilter()) + return { fpn: this.CurrentFilter().PropertyOfDefinition.DisplayName, fpv: this.CuttrentFilter().FilterValue } + return {}; + } + + public CurrentFilter: knockoutObservable> = ko.observable>(); + + } + + + + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +> + ^ + source.ts +> class ConstrainedBasedObjectcolection + ^^^ + source.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts + ^^^^^^^ + source.ts meta.class.ts meta.type.parameters.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts + ^^^^ + source.ts meta.class.ts meta.type.parameters.ts entity.name.type.module.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.class.ts meta.type.parameters.ts entity.name.type.module.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts +> { + ^^^^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> public GetState(): { [index : string]: string } + ^^^^^^^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts +> { + ^^^^^^^^^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +> if (this.ShouldFilter()) + ^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.block.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.block.ts meta.brace.round.ts +> return { fpn: this.CurrentFilter().PropertyOfDefinition.DisplayName, fpv: this.CuttrentFilter().FilterValue } + ^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts + ^^^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^^^^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.object.property.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts + ^^^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^^^^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts +> return {}; + ^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^^^ + source.ts meta.class.ts meta.block.ts + ^ + source.ts meta.class.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> public CurrentFilter: knockoutObservable> = ko.observable>(); + ^^^^^^^^^^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.parameters.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.parameters.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.parameters.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.class.ts +> } + ^^^^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^^ + source.ts +> + ^ + source.ts +> + ^ + source.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue383.baseline.txt b/tests/baselines/Issue383.baseline.txt new file mode 100644 index 00000000..d247707b --- /dev/null +++ b/tests/baselines/Issue383.baseline.txt @@ -0,0 +1,310 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has jsx + +const singleLineArrow = (first: number, second: Set) => (
); + +const multilineArrow = (first: number, + second: number[], +) => (
); + +const multilineArrowWithGenericType = (first: number, + second: Set, +) => (
); + +const followup = (first: number, second: Set) => (
); +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has jsx + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx comment.line.double-slash.tsx +> + ^ + source.tsx +>const singleLineArrow = (first: number, second: Set) => (
); + ^^^^^ + source.tsx meta.var.expr.tsx storage.type.tsx + ^ + source.tsx meta.var.expr.tsx + ^^^^^^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.definition.variable.tsx variable.other.constant.tsx entity.name.function.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx + ^ + source.tsx meta.var.expr.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx support.type.primitive.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.separator.parameter.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx + ^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx entity.name.type.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx meta.type.parameters.tsx support.type.primitive.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx storage.type.function.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.brace.round.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.brace.round.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +> + ^ + source.tsx +>const multilineArrow = (first: number, + ^^^^^ + source.tsx meta.var.expr.tsx storage.type.tsx + ^ + source.tsx meta.var.expr.tsx + ^^^^^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.definition.variable.tsx variable.other.constant.tsx entity.name.function.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx + ^ + source.tsx meta.var.expr.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx support.type.primitive.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.separator.parameter.tsx +> second: number[], + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx support.type.primitive.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx meta.type.tuple.tsx meta.brace.square.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx meta.type.tuple.tsx meta.brace.square.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.separator.parameter.tsx +>) => (
); + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx storage.type.function.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.brace.round.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.brace.round.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +> + ^ + source.tsx +>const multilineArrowWithGenericType = (first: number, + ^^^^^ + source.tsx meta.var.expr.tsx storage.type.tsx + ^ + source.tsx meta.var.expr.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.definition.variable.tsx variable.other.constant.tsx entity.name.function.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx + ^ + source.tsx meta.var.expr.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx support.type.primitive.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.separator.parameter.tsx +> second: Set, + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx + ^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx entity.name.type.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx meta.type.parameters.tsx support.type.primitive.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.separator.parameter.tsx +>) => (
); + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx storage.type.function.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.brace.round.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.brace.round.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +> + ^ + source.tsx +>const followup = (first: number, second: Set) => (
); + ^^^^^ + source.tsx meta.var.expr.tsx storage.type.tsx + ^ + source.tsx meta.var.expr.tsx + ^^^^^^^^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx meta.definition.variable.tsx variable.other.constant.tsx entity.name.function.tsx + ^ + source.tsx meta.var.expr.tsx meta.var-single-variable.expr.tsx + ^ + source.tsx meta.var.expr.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx support.type.primitive.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.separator.parameter.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx + ^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx entity.name.type.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + ^^^^^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx meta.type.parameters.tsx support.type.primitive.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^^ + source.tsx meta.var.expr.tsx meta.arrow.tsx storage.type.function.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.arrow.tsx + ^ + source.tsx meta.var.expr.tsx meta.brace.round.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.var.expr.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.var.expr.tsx meta.brace.round.tsx + ^ + source.tsx punctuation.terminator.statement.tsx \ No newline at end of file diff --git a/tests/baselines/Issue384.baseline.txt b/tests/baselines/Issue384.baseline.txt new file mode 100644 index 00000000..92a51692 --- /dev/null +++ b/tests/baselines/Issue384.baseline.txt @@ -0,0 +1,92 @@ +original file +----------------------------------- +declare function foo(): any +declare function foo(): any + +export function X(): void +export as namespace Y +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>declare function foo(): any + ^^^^^^^ + source.ts meta.function.ts storage.modifier.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts +>declare function foo(): any + ^^^^^^^ + source.ts meta.function.ts storage.modifier.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts +> + ^ + source.ts +>export function X(): void + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts +>export as namespace Y + ^^^^^^ + source.ts keyword.control.export.ts + ^ + source.ts + ^^ + source.ts keyword.control.as.ts + ^ + source.ts + ^^^^^^^^^ + source.ts storage.type.namespace.ts + ^ + source.ts + ^ + source.ts entity.name.type.module.ts \ No newline at end of file diff --git a/tests/baselines/Issue387.baseline.txt b/tests/baselines/Issue387.baseline.txt new file mode 100644 index 00000000..5b74eafe --- /dev/null +++ b/tests/baselines/Issue387.baseline.txt @@ -0,0 +1,420 @@ +original file +----------------------------------- +// +// Copyright 2016 Kary Foundation, Inc. +// Author: Pouya Kary +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. +// + +// +// --- IMPORTS -------------------------------------------------------------------- +// + + import * as readline from 'readline'; + +// +// --- READLINE ------------------------------------------------------------------- +// + + /** + * Reads a string from the command line + * ``` + * async function main ( ) { + * let name = await kary.terminal.input('Your name: ') + * console.log(`Hello, ${ name }!`) + * } + * ``` + */ + export async function input ( message = '' ) { + const readlineInterface = readline.createInterface({ + input: process.stdin, + output: process.stdout, + }) + return new Promise ( resolve => { + readlineInterface.question ( message , answer => { + readlineInterface.close( ); + resolve( answer ); + }); + }); + } + +// -------------------------------------------------------------------------------- +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>// + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts +>// Copyright 2016 Kary Foundation, Inc. + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>// Author: Pouya Kary + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>// + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts +>// This Source Code Form is subject to the terms of the Mozilla Public + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>// License, v. 2.0. If a copy of the MPL was not distributed with this + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>// file, You can obtain one at http://mozilla.org/MPL/2.0/. + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>// + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts +> + ^ + source.ts +>// + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts +>// --- IMPORTS -------------------------------------------------------------------- + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>// + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts +> + ^ + source.ts +> import * as readline from 'readline'; + ^^^^ + source.ts + ^^^^^^ + source.ts meta.import.ts keyword.control.import.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts constant.language.import-export-all.ts + ^ + source.ts meta.import.ts + ^^ + source.ts meta.import.ts keyword.control.as.ts + ^ + source.ts meta.import.ts + ^^^^^^^^ + source.ts meta.import.ts variable.other.readwrite.alias.ts + ^ + source.ts meta.import.ts + ^^^^ + source.ts meta.import.ts keyword.control.from.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^ + source.ts meta.import.ts string.quoted.single.ts + ^ + source.ts meta.import.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>// + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts +>// --- READLINE ------------------------------------------------------------------- + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>// + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts +> + ^ + source.ts +> /** + ^^^^ + source.ts + ^^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +> * Reads a string from the command line + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> * ``` + ^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> * async function main ( ) { + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> * let name = await kary.terminal.input('Your name: ') + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> * console.log(`Hello, ${ name }!`) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> * } + ^^^^^^^^^ + source.ts comment.block.documentation.ts +> * ``` + ^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> */ + ^^^^^ + source.ts comment.block.documentation.ts + ^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +> export async function input ( message = '' ) { + ^^^^ + source.ts + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^ + source.ts meta.function.ts storage.modifier.async.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^^^^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^ + source.ts meta.function.ts meta.parameters.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^ + source.ts meta.function.ts meta.parameters.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> const readlineInterface = readline.createInterface({ + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> input: process.stdin, + ^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts support.variable.object.process.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts support.variable.property.process.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> output: process.stdout, + ^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts support.variable.object.process.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts support.variable.property.process.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> }) + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts +> return new Promise ( resolve => { + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.function-call.ts support.class.promise.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts + ^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> readlineInterface.question ( message , answer => { + ^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts + ^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> readlineInterface.close( ); + ^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> resolve( answer ); + ^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> }); + ^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> }); + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>// -------------------------------------------------------------------------------- + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts \ No newline at end of file diff --git a/tests/baselines/Issue388.baseline.txt b/tests/baselines/Issue388.baseline.txt new file mode 100644 index 00000000..f544549d --- /dev/null +++ b/tests/baselines/Issue388.baseline.txt @@ -0,0 +1,114 @@ +original file +----------------------------------- +export const fun = (param: ParamType): FunResult => { } + +export const fun = + (param: ParamType): + FunResult => { +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export const fun = (param: ParamType): FunResult => { } + ^^^^^^ + source.ts meta.var.expr.ts keyword.control.export.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>export const fun = + ^^^^^^ + source.ts meta.var.expr.ts keyword.control.export.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^^ + source.ts meta.var.expr.ts +> (param: ParamType): + ^^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts +> FunResult => { + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue389.baseline.txt b/tests/baselines/Issue389.baseline.txt new file mode 100644 index 00000000..1463bb5e --- /dev/null +++ b/tests/baselines/Issue389.baseline.txt @@ -0,0 +1,42 @@ +original file +----------------------------------- +[function () +{ + let foo; +}]; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>[function () + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^^^^^^^^ + source.ts meta.array.literal.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.array.literal.ts meta.function.expression.ts + ^ + source.ts meta.array.literal.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.array.literal.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>{ + ^ + source.ts meta.array.literal.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> let foo; + ^^^^ + source.ts meta.array.literal.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.array.literal.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.array.literal.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^ + source.ts meta.array.literal.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.array.literal.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +>}]; + ^ + source.ts meta.array.literal.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue391.baseline.txt b/tests/baselines/Issue391.baseline.txt new file mode 100644 index 00000000..09f3aedb --- /dev/null +++ b/tests/baselines/Issue391.baseline.txt @@ -0,0 +1,490 @@ +original file +----------------------------------- +var interface = require('./../interface'); +var ctrl = require('./controllers'); +var utils = require('./../utils'); +var Promise = require('bluebird'); +var deligate = require('./core'); +var log = require('./../log'); + +var constructor = deligate.then(function(bot) +{ + bot.sendMessage(110224344, 'here is the index'); + bot.on('message', function(message) + { + if(utils.telegram.is_command(message.text)) + { + ctrl.commands(message).catch(function(error_log) + { + bot.sendMessage(message.chat.id, interface.text.errors.redirect); + log.uncaughtException(error_log); + }); + } + }); + + return ' ? Telegram WebHook Set: Successfull!'; +}); + +module.exports = constructor; + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>var interface = require('./../interface'); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>var ctrl = require('./controllers'); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>var utils = require('./../utils'); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>var Promise = require('bluebird'); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>var deligate = require('./core'); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>var log = require('./../log'); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>var constructor = deligate.then(function(bot) + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.promise.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>{ + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> bot.sendMessage(110224344, 'here is the index'); + ^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> bot.on('message', function(message) + ^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts +> { + ^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> if(utils.telegram.is_command(message.text)) + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts +> { + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> ctrl.commands(message).catch(function(error_log) + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.promise.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts +> { + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> bot.sendMessage(message.chat.id, interface.text.errors.redirect); + ^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.object.property.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.object.property.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> log.uncaughtException(error_log); + ^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> }); + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> }); + ^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts +> return ' ? Telegram WebHook Set: Successfull!'; + ^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +>}); + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>module.exports = constructor; + ^^^^^^ + source.ts support.type.object.module.ts + ^ + source.ts punctuation.accessor.ts + ^^^^^^^ + source.ts support.type.object.module.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue393.baseline.txt b/tests/baselines/Issue393.baseline.txt new file mode 100644 index 00000000..95df430a --- /dev/null +++ b/tests/baselines/Issue393.baseline.txt @@ -0,0 +1,104 @@ +original file +----------------------------------- +class ColorsBars extends React.Component { + constructor(...args) { + super(...args) + this.toggleEdit = this.toggleEdit.bind(this) + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class ColorsBars extends React.Component { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts entity.name.type.module.ts + ^ + source.ts meta.class.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> constructor(...args) { + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts keyword.operator.rest.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> super(...args) + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts variable.language.super.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.spread.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts +> this.toggleEdit = this.toggleEdit.bind(this) + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts +> } + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue394.baseline.txt b/tests/baselines/Issue394.baseline.txt new file mode 100644 index 00000000..d5703a79 --- /dev/null +++ b/tests/baselines/Issue394.baseline.txt @@ -0,0 +1,156 @@ +original file +----------------------------------- + gulp.add('watch-' + (asset.name || asset.route), function () + { + gulp.watch('./modules/*' + asset.moduleRelativePath, ['build-' + (asset.name || asset.route)]); + }); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +> gulp.add('watch-' + (asset.name || asset.route), function () + ^ + source.ts + ^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts string.quoted.single.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^^^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^^^ + source.ts support.variable.property.dom.ts + ^ + source.ts + ^^ + source.ts keyword.operator.logical.ts + ^ + source.ts + ^^^^^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^^^^ + source.ts variable.other.property.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts + ^^^^^^^^ + source.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.function.expression.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts +> { + ^^^^^^^^ + source.ts meta.function.expression.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> gulp.watch('./modules/*' + asset.moduleRelativePath, ['build-' + (asset.name || asset.route)]); + ^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.function.expression.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts support.variable.property.dom.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts keyword.operator.logical.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts variable.other.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> }); + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue396.baseline.txt b/tests/baselines/Issue396.baseline.txt new file mode 100644 index 00000000..88fe0ca4 --- /dev/null +++ b/tests/baselines/Issue396.baseline.txt @@ -0,0 +1,236 @@ +original file +----------------------------------- +/* jshint esnext:true */ +let it = require('./it'); +it.execute(function* builder(options) { + let metaData = yield it.read(option.metaFile); + it.meta = yield it.parse(metaData, { + ICON: yield it.read(options.icon), + ICON64: (yield it.read(options.icon64)).base64() + }); +}); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/* jshint esnext:true */ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +>let it = require('./it'); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>it.execute(function* builder(options) { + ^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^ + source.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.function.expression.ts keyword.generator.asterisk.ts + ^ + source.ts meta.function.expression.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.expression.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> let metaData = yield it.read(option.metaFile); + ^^^ + source.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.control.flow.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> it.meta = yield it.parse(metaData, { + ^^^ + source.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts +> ICON: yield it.read(options.icon), + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts keyword.control.flow.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts punctuation.separator.comma.ts +> ICON64: (yield it.read(options.icon64)).base64() + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts keyword.control.flow.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts +> }); + ^^^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +>}); + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue397.baseline.txt b/tests/baselines/Issue397.baseline.txt new file mode 100644 index 00000000..a486506e --- /dev/null +++ b/tests/baselines/Issue397.baseline.txt @@ -0,0 +1,54 @@ +original file +----------------------------------- +const a = Math.max(...x); +const b = 2; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const a = Math.max(...x); + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.constant.math.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.var.expr.ts meta.function-call.ts support.function.math.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^^^ + source.ts meta.var.expr.ts keyword.operator.spread.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>const b = 2; + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue398.baseline.txt b/tests/baselines/Issue398.baseline.txt new file mode 100644 index 00000000..d8ac6886 --- /dev/null +++ b/tests/baselines/Issue398.baseline.txt @@ -0,0 +1,68 @@ +original file +----------------------------------- +let x: Array<{ name: string, fn(): any, field: string }> +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let x: Array<{ name: string, fn(): any, field: string }> + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.field.declaration.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.method.declaration.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.method.declaration.ts meta.return.type.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.field.declaration.ts + ^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts \ No newline at end of file diff --git a/tests/baselines/Issue402.baseline.txt b/tests/baselines/Issue402.baseline.txt new file mode 100644 index 00000000..eb097903 --- /dev/null +++ b/tests/baselines/Issue402.baseline.txt @@ -0,0 +1,550 @@ +original file +----------------------------------- +ipcMain.on('ELECTRON_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', function (event, guestId, method, ...args) { + const guestContents = webContents.fromId(guestId) + if (guestContents == null) return + + if (canAccessWindow(event.sender, guestContents)) { + guestContents[method](...args) + } else { + console.error(`Blocked ${event.sender.getURL()} from calling ${method} on its opener.`) + } +}) + +ipcMain.on('ELECTRON_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD_SYNC', function (event, guestId, method, ...args) { + const guestContents = webContents.fromId(guestId) + if (guestContents == null) { + event.returnValue = null + return + } + + if (canAccessWindow(event.sender, guestContents)) { + event.returnValue = guestContents[method](...args) + } else { + console.error(`Blocked ${event.sender.getURL()} from calling ${method} on its opener.`) + event.returnValue = null + } +}) +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>ipcMain.on('ELECTRON_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', function (event, guestId, method, ...args) { + ^^^^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts string.quoted.single.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts + ^^^^^^^^ + source.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.function.expression.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts + ^^^ + source.ts meta.function.expression.ts meta.parameters.ts keyword.operator.rest.ts + ^^^^ + source.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.expression.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> const guestContents = webContents.fromId(guestId) + ^^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts +> if (guestContents == null) return + ^^ + source.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts constant.language.null.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts keyword.control.flow.ts +> + ^ + source.ts meta.function.expression.ts meta.block.ts +> if (canAccessWindow(event.sender, guestContents)) { + ^^ + source.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts support.variable.dom.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> guestContents[method](...args) + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts keyword.operator.spread.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts +> } else { + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> console.error(`Blocked ${event.sender.getURL()} from calling ${method} on its opener.`) + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts support.variable.dom.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts +> } + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +>}) + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts +> + ^ + source.ts +>ipcMain.on('ELECTRON_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD_SYNC', function (event, guestId, method, ...args) { + ^^^^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts string.quoted.single.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts + ^^^^^^^^ + source.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.function.expression.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts + ^^^ + source.ts meta.function.expression.ts meta.parameters.ts keyword.operator.rest.ts + ^^^^ + source.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.expression.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> const guestContents = webContents.fromId(guestId) + ^^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts +> if (guestContents == null) { + ^^ + source.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts constant.language.null.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> event.returnValue = null + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts support.variable.dom.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts constant.language.null.ts +> return + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts keyword.control.flow.ts +> } + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.function.expression.ts meta.block.ts +> if (canAccessWindow(event.sender, guestContents)) { + ^^ + source.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts support.variable.dom.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> event.returnValue = guestContents[method](...args) + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts support.variable.dom.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts keyword.operator.spread.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts +> } else { + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> console.error(`Blocked ${event.sender.getURL()} from calling ${method} on its opener.`) + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts support.variable.dom.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts meta.brace.round.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts variable.other.readwrite.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^^^^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts meta.brace.round.ts +> event.returnValue = null + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts support.variable.dom.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts constant.language.null.ts +> } + ^^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +>}) + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts \ No newline at end of file diff --git a/tests/baselines/Issue403IncorrectlyDetectedArrowTypeParameters.baseline.txt b/tests/baselines/Issue403IncorrectlyDetectedArrowTypeParameters.baseline.txt new file mode 100644 index 00000000..522a8ecf --- /dev/null +++ b/tests/baselines/Issue403IncorrectlyDetectedArrowTypeParameters.baseline.txt @@ -0,0 +1,1452 @@ +original file +----------------------------------- +e.ui.plugin.add("resizable", "grid", { + resize: function() { + var t = e(this).data("ui-resizable"), + n = t.options, + r = t.size, + i = t.originalSize, + s = t.originalPosition, + o = t.axis, + u = typeof n.grid == "number" ? [n.grid, n.grid] : n.grid, + a = u[0] || 1, + f = u[1] || 1, + l = Math.round((r.width - i.width) / a) * a, + c = Math.round((r.height - i.height) / f) * f, + h = i.width + l, + p = i.height + c, + d = n.maxWidth && n.maxWidth < h, + v = n.maxHeight && n.maxHeight < p, + m = n.minWidth && n.minWidth > h, + g = n.minHeight && n.minHeight > p; + n.grid = u, m && (h += a), g && (p += f), d && (h -= a), v && (p -= f), /^(se|s|e)$/.test(o) ? (t.size.width = h, t.size.height = p) : /^(ne)$/.test(o) ? (t.size.width = h, t.size.height = p, t.position.top = s.top - c) : /^(sw)$/.test(o) ? (t.size.width = h, t.size.height = p, t.position.left = s.left - l) : (p - f > 0 ? (t.size.height = p, t.position.top = s.top - c) : (t.size.height = f, t.position.top = s.top + i.height - f), h - a > 0 ? (t.size.width = h, t.position.left = s.left - l) : (t.size.width = a, t.position.left = s.left + i.width - a)) + } + }) +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>e.ui.plugin.add("resizable", "grid", { + ^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^ + source.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^ + source.ts string.quoted.double.ts + ^ + source.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts + ^ + source.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts string.quoted.double.ts + ^ + source.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts +> resize: function() { + ^^^^^^^^^^^^ + source.ts meta.objectliteral.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts entity.name.function.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> var t = e(this).data("ui-resizable"), + ^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.language.this.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> n = t.options, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> r = t.size, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> i = t.originalSize, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> s = t.originalPosition, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> o = t.axis, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> u = typeof n.grid == "number" ? [n.grid, n.grid] : n.grid, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.expression.typeof.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.comparison.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> a = u[0] || 1, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.logical.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> f = u[1] || 1, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.logical.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> l = Math.round((r.width - i.width) / a) * a, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts support.constant.math.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts support.function.math.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> c = Math.round((r.height - i.height) / f) * f, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts support.constant.math.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.function-call.ts support.function.math.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> h = i.width + l, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> p = i.height + c, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> d = n.maxWidth && n.maxWidth < h, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.logical.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.relational.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> v = n.maxHeight && n.maxHeight < p, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.logical.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.relational.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> m = n.minWidth && n.minWidth > h, + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.logical.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.relational.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> g = n.minHeight && n.minHeight > p; + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.logical.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts keyword.operator.relational.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.terminator.statement.ts +> n.grid = u, m && (h += a), g && (p += f), d && (h -= a), v && (p -= f), /^(se|s|e)$/.test(o) ? (t.size.width = h, t.size.height = p) : /^(ne)$/.test(o) ? (t.size.width = h, t.size.height = p, t.position.top = s.top - c) : /^(sw)$/.test(o) ? (t.size.width = h, t.size.height = p, t.position.left = s.left - l) : (p - f > 0 ? (t.size.height = p, t.position.top = s.top - c) : (t.size.height = f, t.position.top = s.top + i.height - f), h - a > 0 ? (t.size.width = h, t.position.left = s.left - l) : (t.size.width = a, t.position.left = s.left + i.width - a)) + ^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.compound.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.compound.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.compound.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.compound.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts keyword.control.anchor.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts meta.group.regexp punctuation.definition.group.regexp + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts meta.group.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts meta.group.regexp keyword.operator.or.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts meta.group.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts meta.group.regexp keyword.operator.or.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts meta.group.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts meta.group.regexp punctuation.definition.group.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts keyword.control.anchor.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts keyword.control.anchor.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts meta.group.regexp punctuation.definition.group.regexp + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts meta.group.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts meta.group.regexp punctuation.definition.group.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts keyword.control.anchor.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts keyword.control.anchor.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts meta.group.regexp punctuation.definition.group.regexp + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts meta.group.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts meta.group.regexp punctuation.definition.group.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts keyword.control.anchor.regexp + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.property.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts support.variable.property.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts +> } + ^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> }) + ^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts \ No newline at end of file diff --git a/tests/baselines/Issue403IncorrectlyDetectedFunctionCallAsArrow.baseline.txt b/tests/baselines/Issue403IncorrectlyDetectedFunctionCallAsArrow.baseline.txt new file mode 100644 index 00000000..40d681ba --- /dev/null +++ b/tests/baselines/Issue403IncorrectlyDetectedFunctionCallAsArrow.baseline.txt @@ -0,0 +1,430 @@ +original file +----------------------------------- +p.parseJSON = function(t) { + if (e.JSON && e.JSON.parse) return e.JSON.parse(t + ""); + var n, r = null, + i = p.trim(t + ""); + return i && !p.trim(i.replace(Nn, function(e, t, i, s) { + return n && t && (r = 0), r === 0 ? e : (n = i || t, r += !s - !i, "") + })) ? Function("return " + i)() : p.error("Invalid JSON: " + t) + } +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>p.parseJSON = function(t) { + ^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts entity.name.function.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> if (e.JSON && e.JSON.parse) return e.JSON.parse(t + ""); + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.ts meta.block.ts variable.other.constant.property.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.ts meta.block.ts variable.other.constant.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.constant.object.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +> var n, r = null, + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.language.null.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts +> i = p.trim(t + ""); + ^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +> return i && !p.trim(i.replace(Nn, function(e, t, i, s) { + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.parameters.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.parameters.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.parameters.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> return n && t && (r = 0), r === 0 ? e : (n = i || t, r += !s - !i, "") + ^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.operator.comparison.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.operator.assignment.compound.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts +> })) ? Function("return " + i)() : p.error("Invalid JSON: " + t) + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts +> } + ^^^^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue405.baseline.txt b/tests/baselines/Issue405.baseline.txt new file mode 100644 index 00000000..42913a39 --- /dev/null +++ b/tests/baselines/Issue405.baseline.txt @@ -0,0 +1,144 @@ +original file +----------------------------------- +function myFunction1 + (a: string) +{ + var r = true; + return true +} + +function myFunction2 + (a: string): boolean +{ + var r = true; + return true +} + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function myFunction1 + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^^ + source.ts meta.function.ts + ^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts +> (a: string) + ^^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts +>{ + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> var r = true; + ^^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.language.boolean.true.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +> return true + ^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^ + source.ts meta.function.ts meta.block.ts constant.language.boolean.true.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>function myFunction2 + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts +> (a: string): boolean + ^^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts +>{ + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> var r = true; + ^^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.language.boolean.true.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +> return true + ^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^ + source.ts meta.function.ts meta.block.ts constant.language.boolean.true.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue407.baseline.txt b/tests/baselines/Issue407.baseline.txt new file mode 100644 index 00000000..f96c002e --- /dev/null +++ b/tests/baselines/Issue407.baseline.txt @@ -0,0 +1,62 @@ +original file +----------------------------------- +let x: Map; +let Y: Map; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let x: Map; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>let Y: Map; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue408.baseline.txt b/tests/baselines/Issue408.baseline.txt new file mode 100644 index 00000000..fd9dc246 --- /dev/null +++ b/tests/baselines/Issue408.baseline.txt @@ -0,0 +1,40 @@ +original file +----------------------------------- +assert(truthyValue, 'must be true'); +path(pathArgs); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>assert(truthyValue, 'must be true'); + ^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^ + source.ts string.quoted.single.ts + ^ + source.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>path(pathArgs); + ^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue415.baseline.txt b/tests/baselines/Issue415.baseline.txt new file mode 100644 index 00000000..a7801837 --- /dev/null +++ b/tests/baselines/Issue415.baseline.txt @@ -0,0 +1,150 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has jsx +(); +(); +(); +(); +(); +(); +(bold); +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has jsx + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx comment.line.double-slash.tsx +>(); + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^^^^ + source.tsx meta.tag.tsx entity.name.tag.tsx support.class.component.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^ + source.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +>(); + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^^^^^^^^ + source.tsx meta.tag.tsx entity.name.tag.tsx support.class.component.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^ + source.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +>(); + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^^^^^^^^ + source.tsx meta.tag.tsx entity.name.tag.tsx support.class.component.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^ + source.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +>(); + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^^^^^^^^ + source.tsx meta.tag.tsx entity.name.tag.tsx support.class.component.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^ + source.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +>(); + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^ + source.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx support.class.component.tsx + ^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^ + source.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx support.class.component.tsx + ^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +>(); + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^^^ + source.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx support.class.component.tsx + ^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^^^ + source.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx support.class.component.tsx + ^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +>(bold); + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^^^ + source.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx support.class.component.tsx + ^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^^^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx + ^ + source.tsx meta.tag.without-attributes.tsx meta.jsx.children.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.begin.tsx + ^^^^^^^^ + source.tsx meta.tag.without-attributes.tsx entity.name.tag.tsx support.class.component.tsx + ^ + source.tsx meta.tag.without-attributes.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx punctuation.terminator.statement.tsx \ No newline at end of file diff --git a/tests/baselines/Issue417.baseline.txt b/tests/baselines/Issue417.baseline.txt new file mode 100644 index 00000000..1736c2e0 --- /dev/null +++ b/tests/baselines/Issue417.baseline.txt @@ -0,0 +1,66 @@ +original file +----------------------------------- +const a = { + 1: '1', + '2': '2', +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const a = { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> 1: '1', + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> '2': '2', + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +>} + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue418.baseline.txt b/tests/baselines/Issue418.baseline.txt new file mode 100644 index 00000000..1199b341 --- /dev/null +++ b/tests/baselines/Issue418.baseline.txt @@ -0,0 +1,498 @@ +original file +----------------------------------- +function merge(as, bs) { + let res = [] + let ia = 0 + let ib = 0 + while (ia < as.length && ib < bs.length) { // coloring broken + if (as[ia] < bs[ib]) { + res.push(as[ia++]) // coloring broken + } else { + res.push(bs[ib++]) // coloring broken + } + } + return res.concat(as.slice(ia)).concat(bs.slice(ib)) // coloring broken +} + +function mergesort(array) { + if (array.length < 2) { + return array + } + const mid = Math.floor(array.length / 2) + return merge(mergesort(array.slice(0, mid)), mergesort(array.slice(mid))) +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function merge(as, bs) { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> let res = [] + ^^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts +> let ia = 0 + ^^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts +> let ib = 0 + ^^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts +> while (ia < as.length && ib < bs.length) { // coloring broken + ^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.loop.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts support.variable.property.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts support.variable.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts comment.line.double-slash.ts +> if (as[ia] < bs[ib]) { + ^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> res.push(as[ia++]) // coloring broken + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.array.literal.ts variable.other.readwrite.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.array.literal.ts keyword.operator.increment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts comment.line.double-slash.ts +> } else { + ^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> res.push(bs[ib++]) // coloring broken + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.array.literal.ts variable.other.readwrite.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.array.literal.ts keyword.operator.increment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts comment.line.double-slash.ts +> } + ^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> } + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> return res.concat(as.slice(ia)).concat(bs.slice(ib)) // coloring broken + ^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts comment.line.double-slash.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>function mergesort(array) { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> if (array.length < 2) { + ^^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts support.variable.property.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> return array + ^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts variable.other.readwrite.ts +> } + ^^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> const mid = Math.floor(array.length / 2) + ^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.function-call.ts support.constant.math.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.function-call.ts support.function.math.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts support.variable.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts +> return merge(mergesort(array.slice(0, mid)), mergesort(array.slice(mid))) + ^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue42.baseline.txt b/tests/baselines/Issue42.baseline.txt new file mode 100644 index 00000000..9a2ec714 --- /dev/null +++ b/tests/baselines/Issue42.baseline.txt @@ -0,0 +1,104 @@ +original file +----------------------------------- + return this.travelWorld((cell: Cell) => { + cell.live = Math.random() < this.initialLifeProbability; + return cell; + }); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +> return this.travelWorld((cell: Cell) => { + ^^^^^^^^^^^^ + source.ts + ^^^^^^ + source.ts keyword.control.flow.ts + ^ + source.ts + ^^^^ + source.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^ + source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^ + source.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> cell.live = Math.random() < this.initialLifeProbability; + ^^^^^^^^^^^^^^^^ + source.ts meta.arrow.ts meta.block.ts + ^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^^^^ + source.ts meta.arrow.ts meta.block.ts meta.function-call.ts support.constant.math.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.function-call.ts support.function.math.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^^^^ + source.ts meta.arrow.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> return cell; + ^^^^^^^^^^^^^^^^ + source.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> }); + ^^^^^^^^^^^^ + source.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue420.baseline.txt b/tests/baselines/Issue420.baseline.txt new file mode 100644 index 00000000..d6b8cbd4 --- /dev/null +++ b/tests/baselines/Issue420.baseline.txt @@ -0,0 +1,60 @@ +original file +----------------------------------- +verify.quickInfos({ + 1: "this: ContextualInterface", + 2: "(parameter) this: void" +}); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>verify.quickInfos({ + ^^^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts +> 1: "this: ContextualInterface", + ^^^^ + source.ts meta.objectliteral.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts constant.numeric.decimal.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.objectliteral.ts punctuation.separator.comma.ts +> 2: "(parameter) this: void" + ^^^^ + source.ts meta.objectliteral.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts constant.numeric.decimal.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts +>}); + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue421.baseline.txt b/tests/baselines/Issue421.baseline.txt new file mode 100644 index 00000000..373ca3f3 --- /dev/null +++ b/tests/baselines/Issue421.baseline.txt @@ -0,0 +1,78 @@ +original file +----------------------------------- +function f( + arg: 'x' | + 'y', + arg2: 1 | + 2) {} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function f( + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts +> arg: 'x' | + ^^^^^^^^ + source.ts meta.function.ts meta.parameters.ts + ^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts string.quoted.single.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.ts +> 'y', + ^^^^^^^^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts string.quoted.single.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts +> arg2: 1 | + ^^^^^^^^ + source.ts meta.function.ts meta.parameters.ts + ^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.ts +> 2) {} + ^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue423.baseline.txt b/tests/baselines/Issue423.baseline.txt new file mode 100644 index 00000000..1492382e --- /dev/null +++ b/tests/baselines/Issue423.baseline.txt @@ -0,0 +1,100 @@ +original file +----------------------------------- +interface Foo { + bar: string; +} + +type T = Foo; // line 5 +interface Bar { + foo: Foo; // line 7 +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>interface Foo { + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> bar: string; + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> + ^ + source.ts +>type T = Foo; // line 5 + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^^^ + source.ts meta.type.declaration.ts entity.name.type.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^ + source.ts comment.line.double-slash.ts +>interface Bar { + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> foo: Foo; // line 7 + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts + ^^ + source.ts meta.interface.ts + ^^ + source.ts meta.interface.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^ + source.ts meta.interface.ts comment.line.double-slash.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue427.baseline.txt b/tests/baselines/Issue427.baseline.txt new file mode 100644 index 00000000..875e0c49 --- /dev/null +++ b/tests/baselines/Issue427.baseline.txt @@ -0,0 +1,190 @@ +original file +----------------------------------- +function a(): { [key: string]: number } | { [key: string]: number } { throw 1 } + +function b(a: { [key: string]: number } | { [key: string]: number }): void { } +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function a(): { [key: string]: number } | { [key: string]: number } { throw 1 } + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.trycatch.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>function b(a: { [key: string]: number } | { [key: string]: number }): void { } + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.indexer.declaration.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts meta.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue428.baseline.txt b/tests/baselines/Issue428.baseline.txt new file mode 100644 index 00000000..8a084d66 --- /dev/null +++ b/tests/baselines/Issue428.baseline.txt @@ -0,0 +1,138 @@ +original file +----------------------------------- +export function funct + (a: number): string + +export function funct + (a: number): number + +// this is implementation +export function funct + (a: number): any { + + } +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export function funct + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts +> (a: number): string + ^^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts +> + ^ + source.ts +>export function funct + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts +> (a: number): number + ^^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts +> + ^ + source.ts +>// this is implementation + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>export function funct + ^^^^^^ + source.ts meta.function.ts keyword.control.export.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts +> (a: number): any { + ^^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^^^ + source.ts meta.function.ts meta.block.ts +> } + ^^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue43.baseline.txt b/tests/baselines/Issue43.baseline.txt new file mode 100644 index 00000000..03271f80 --- /dev/null +++ b/tests/baselines/Issue43.baseline.txt @@ -0,0 +1,50 @@ +original file +----------------------------------- +var $this = $(this); +$this.addClass("hehe"); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>var $this = $(this); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^^^^ + source.ts meta.var.expr.ts variable.language.this.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>$this.addClass("hehe"); + ^^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts string.quoted.double.ts + ^ + source.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue430.baseline.txt b/tests/baselines/Issue430.baseline.txt new file mode 100644 index 00000000..d0de13ba --- /dev/null +++ b/tests/baselines/Issue430.baseline.txt @@ -0,0 +1,264 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has jsx +class c { +render() { + return this.props.data.weekDays.filter((weekDay, index) => (this.state.showAll || index < 3)).map((weekDay, key) => ( +

+ {weekDay.label} {this.props.data[weekDay.id].start} - {this.props.data[weekDay.id].finish} +

+ )) + } +} +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has jsx + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx comment.line.double-slash.tsx +>class c { + ^^^^^ + source.tsx meta.class.tsx storage.type.class.tsx + ^ + source.tsx meta.class.tsx + ^ + source.tsx meta.class.tsx entity.name.type.class.tsx + ^ + source.tsx meta.class.tsx + ^ + source.tsx meta.class.tsx punctuation.definition.block.tsx +>render() { + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.definition.method.tsx entity.name.function.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx punctuation.definition.block.tsx +> return this.props.data.weekDays.filter((weekDay, index) => (this.state.showAll || index < 3)).map((weekDay, key) => ( + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx keyword.control.flow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.function-call.tsx variable.language.this.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.function-call.tsx variable.other.object.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.function-call.tsx support.variable.property.dom.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.function-call.tsx variable.other.object.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.function-call.tsx entity.name.function.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.brace.round.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.parameters.tsx punctuation.separator.parameter.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.parameters.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx storage.type.function.arrow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.brace.round.tsx + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx variable.language.this.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx punctuation.accessor.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx variable.other.object.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx punctuation.accessor.tsx + ^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx variable.other.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx keyword.operator.logical.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx keyword.operator.relational.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx constant.numeric.decimal.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.brace.round.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.brace.round.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.function-call.tsx entity.name.function.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.brace.round.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.parameters.tsx punctuation.separator.parameter.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.parameters.tsx + ^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx storage.type.function.arrow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.brace.round.tsx +>

+ ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx punctuation.section.embedded.begin.tsx + ^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx punctuation.section.embedded.end.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx punctuation.definition.tag.end.tsx +> {weekDay.label} {this.props.data[weekDay.id].start} - {this.props.data[weekDay.id].finish} + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.begin.tsx + ^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx variable.other.object.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx support.variable.property.dom.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.end.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.begin.tsx + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx variable.language.this.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx variable.other.object.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx support.variable.property.dom.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.array.literal.tsx meta.brace.square.tsx + ^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.array.literal.tsx variable.other.object.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.array.literal.tsx punctuation.accessor.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.array.literal.tsx support.variable.property.dom.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.array.literal.tsx meta.brace.square.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx support.variable.property.dom.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.end.tsx + ^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.begin.tsx + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx variable.language.this.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx variable.other.object.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx support.variable.property.dom.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.array.literal.tsx meta.brace.square.tsx + ^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.array.literal.tsx variable.other.object.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.array.literal.tsx punctuation.accessor.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.array.literal.tsx support.variable.property.dom.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.array.literal.tsx meta.brace.square.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx variable.other.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.end.tsx +>

+ ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.tag.tsx punctuation.definition.tag.end.tsx +> )) + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.arrow.tsx meta.brace.round.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.brace.round.tsx +> } + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx punctuation.definition.block.tsx +>} + ^ + source.tsx meta.class.tsx punctuation.definition.block.tsx \ No newline at end of file diff --git a/tests/baselines/Issue431.baseline.txt b/tests/baselines/Issue431.baseline.txt new file mode 100644 index 00000000..83442e27 --- /dev/null +++ b/tests/baselines/Issue431.baseline.txt @@ -0,0 +1,48 @@ +original file +----------------------------------- +myFunc +(...argName) + +function otherFunc() {} // <-- Not highlighted. +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>myFunc + ^^^^^^ + source.ts variable.other.readwrite.ts +>(...argName) + ^ + source.ts meta.brace.round.ts + ^^^ + source.ts keyword.operator.spread.ts + ^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts +> + ^ + source.ts +>function otherFunc() {} // <-- Not highlighted. + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts \ No newline at end of file diff --git a/tests/baselines/Issue433.baseline.txt b/tests/baselines/Issue433.baseline.txt new file mode 100644 index 00000000..588424bf --- /dev/null +++ b/tests/baselines/Issue433.baseline.txt @@ -0,0 +1,44 @@ +original file +----------------------------------- +declare module ILogin{ + export interface Z {} +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>declare module ILogin{ + ^^^^^^^ + source.ts meta.namespace.declaration.ts storage.modifier.ts + ^ + source.ts meta.namespace.declaration.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts storage.type.namespace.ts + ^ + source.ts meta.namespace.declaration.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts entity.name.type.module.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts +> export interface Z {} + ^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.interface.ts keyword.control.export.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.interface.ts + ^^^^^^^^^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.interface.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.interface.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.interface.ts punctuation.definition.block.ts + ^ + source.ts meta.namespace.declaration.ts meta.block.ts meta.interface.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.namespace.declaration.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue434.baseline.txt b/tests/baselines/Issue434.baseline.txt new file mode 100644 index 00000000..b628476c --- /dev/null +++ b/tests/baselines/Issue434.baseline.txt @@ -0,0 +1,302 @@ +original file +----------------------------------- +export class SomeClass { + private someMethod(): void { + if (1 + < 2) { + console.log("TypeScript syntax highlighting is broken!"); + } + else if (1 > 2) { + console.log(""); + } + } + + private someOtherMethod() { + console.log(""); + // + const q = 1; + var s = 2; + let e = 3; + } + + q = 100; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export class SomeClass { + ^^^^^^ + source.ts meta.class.ts keyword.control.export.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> private someMethod(): void { + ^^^^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> if (1 + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts +> < 2) { + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> console.log("TypeScript syntax highlighting is broken!"); + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> else if (1 > 2) { + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> console.log(""); + ^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> private someOtherMethod() { + ^^^^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts storage.modifier.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> console.log(""); + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> // + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts +> const q = 1; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> var s = 2; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> let e = 3; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> q = 100; + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue435.baseline.txt b/tests/baselines/Issue435.baseline.txt new file mode 100644 index 00000000..bd4bb4c9 --- /dev/null +++ b/tests/baselines/Issue435.baseline.txt @@ -0,0 +1,72 @@ +original file +----------------------------------- +/** + * Manually add an item to the uploading queue. + * + * @param {PIXI.DisplayObject|PIXI.Container|PIXI.BaseTexture|PIXI.Texture|PIXI.Graphics|PIXI.Text|*} item - Object to + * add to the queue + * @return {PIXI.CanvasPrepare} Instance of plugin for chaining. + */ +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/** + ^^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +> * Manually add an item to the uploading queue. + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> * + ^^^^^^^ + source.ts comment.block.documentation.ts +> * @param {PIXI.DisplayObject|PIXI.Container|PIXI.BaseTexture|PIXI.Texture|PIXI.Graphics|PIXI.Text|*} item - Object to + ^^^^^^^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc + ^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.begin.jsdoc + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.end.jsdoc + ^ + source.ts comment.block.documentation.ts + ^^^^ + source.ts comment.block.documentation.ts variable.other.jsdoc + ^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> * add to the queue + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> * @return {PIXI.CanvasPrepare} Instance of plugin for chaining. + ^^^^^^^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc + ^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.begin.jsdoc + ^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.end.jsdoc + ^ + source.ts comment.block.documentation.ts + ^^^^^^^^ + source.ts comment.block.documentation.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> */ + ^^^^^ + source.ts comment.block.documentation.ts + ^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts \ No newline at end of file diff --git a/tests/baselines/Issue44.baseline.txt b/tests/baselines/Issue44.baseline.txt new file mode 100644 index 00000000..13d1da01 --- /dev/null +++ b/tests/baselines/Issue44.baseline.txt @@ -0,0 +1,78 @@ +original file +----------------------------------- + +interface TestInterface { + testvar: string; + testfunc(): string; +} + +/* + Testing Comments +*/ + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +> + ^ + source.ts +>interface TestInterface { + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^^^^^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> testvar: string; + ^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +> testfunc(): string; + ^^ + source.ts meta.interface.ts meta.method.declaration.ts + ^^^^^^^^ + source.ts meta.interface.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.interface.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> + ^ + source.ts +>/* + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +> Testing Comments + ^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts +>*/ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue44.txt b/tests/baselines/Issue44.txt deleted file mode 100644 index c3e1e74a..00000000 --- a/tests/baselines/Issue44.txt +++ /dev/null @@ -1,7 +0,0 @@ -[2, 1]: source.ts meta.declaration.object.ts storage.type.ts -[2, 11]: source.ts meta.declaration.object.ts meta.object.name.ts entity.name.class.ts -[3, 3]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts variable.ts -[3, 12]: source.ts meta.declaration.object.ts meta.object.body.ts meta.field.declaration.ts meta.type.primitive.ts support.type.ts -[4, 3]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts entity.name.function.ts -[4, 15]: source.ts meta.declaration.object.ts meta.object.body.ts meta.method.declaration.ts meta.type.annotation.ts meta.type.primitive.ts support.type.ts -[5, 1]: source.ts meta.declaration.object.ts meta.object.body.ts meta.brace.curly.ts \ No newline at end of file diff --git a/tests/baselines/Issue441.baseline.txt b/tests/baselines/Issue441.baseline.txt new file mode 100644 index 00000000..57cea99b --- /dev/null +++ b/tests/baselines/Issue441.baseline.txt @@ -0,0 +1,26 @@ +original file +----------------------------------- +func(1) +async(1) +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>func(1) + ^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts meta.brace.round.ts +>async(1) + ^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts meta.brace.round.ts \ No newline at end of file diff --git a/tests/baselines/Issue444.baseline.txt b/tests/baselines/Issue444.baseline.txt new file mode 100644 index 00000000..df6e511a --- /dev/null +++ b/tests/baselines/Issue444.baseline.txt @@ -0,0 +1,232 @@ +original file +----------------------------------- +var test = "123 456"; + +if ((test.match(/\d+/g)[0]) / (test.match(/\d+/g)[1]) < 1) { + return; +} + +if ((test.match(/\d+/g)[0])/(test.match(/\d+/g)[1]) < 1) { + return; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>var test = "123 456"; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>if ((test.match(/\d+/g)[0]) / (test.match(/\d+/g)[1]) < 1) { + ^^ + source.ts keyword.control.conditional.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts + ^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.regexp.ts punctuation.definition.string.begin.ts + ^^ + source.ts string.regexp.ts constant.other.character-class.regexp + ^ + source.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts string.regexp.ts keyword.other.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.regexp.ts punctuation.definition.string.begin.ts + ^^ + source.ts string.regexp.ts constant.other.character-class.regexp + ^ + source.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts string.regexp.ts keyword.other.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts keyword.operator.relational.ts + ^ + source.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> return; + ^^^^ + source.ts meta.block.ts + ^^^^^^ + source.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>if ((test.match(/\d+/g)[0])/(test.match(/\d+/g)[1]) < 1) { + ^^ + source.ts keyword.control.conditional.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts + ^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.regexp.ts punctuation.definition.string.begin.ts + ^^ + source.ts string.regexp.ts constant.other.character-class.regexp + ^ + source.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts string.regexp.ts keyword.other.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.brace.round.ts + ^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.regexp.ts punctuation.definition.string.begin.ts + ^^ + source.ts string.regexp.ts constant.other.character-class.regexp + ^ + source.ts string.regexp.ts keyword.operator.quantifier.regexp + ^ + source.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts string.regexp.ts keyword.other.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts keyword.operator.relational.ts + ^ + source.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> return; + ^^^^ + source.ts meta.block.ts + ^^^^^^ + source.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue445.baseline.txt b/tests/baselines/Issue445.baseline.txt new file mode 100644 index 00000000..ecfe1972 --- /dev/null +++ b/tests/baselines/Issue445.baseline.txt @@ -0,0 +1,110 @@ +original file +----------------------------------- +/** + * My awesome function. + * @param {{id: string, name: string}} object An object with an id and name field. + */ +function myAwesomeFunction(object) { + const { name, id } = object. + // do stuff with name and id +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/** + ^^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +> * My awesome function. + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> * @param {{id: string, name: string}} object An object with an id and name field. + ^^^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc + ^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.begin.jsdoc + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.end.jsdoc + ^ + source.ts comment.block.documentation.ts + ^^^^^^ + source.ts comment.block.documentation.ts variable.other.jsdoc + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> */ + ^ + source.ts comment.block.documentation.ts + ^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +>function myAwesomeFunction(object) { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> const { name, id } = object. + ^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts punctuation.definition.binding-pattern.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts punctuation.definition.binding-pattern.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.object-binding-pattern-variable.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts punctuation.accessor.ts +> // do stuff with name and id + ^^ + source.ts meta.function.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.function.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts comment.line.double-slash.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue450.baseline.txt b/tests/baselines/Issue450.baseline.txt new file mode 100644 index 00000000..be837fae --- /dev/null +++ b/tests/baselines/Issue450.baseline.txt @@ -0,0 +1,58 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has type assertion +let a = true ? 1 : 2; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has type assertion + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>let a = true ? 1 : 2; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.language.boolean.true.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts meta.var.expr.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts meta.var.expr.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue452.baseline.txt b/tests/baselines/Issue452.baseline.txt new file mode 100644 index 00000000..1f33cbeb --- /dev/null +++ b/tests/baselines/Issue452.baseline.txt @@ -0,0 +1,90 @@ +original file +----------------------------------- +class Test{} +class Favorite extends Test< + string | number, + undefined +> { + // class content +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Test{} + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class Favorite extends Test< + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts +> string | number, + ^^ + source.ts meta.class.ts meta.type.parameters.ts + ^^^^^^ + source.ts meta.class.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts keyword.operator.type.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts + ^^^^^^ + source.ts meta.class.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.type.parameters.ts punctuation.separator.comma.ts +> undefined + ^^ + source.ts meta.class.ts meta.type.parameters.ts + ^^^^^^^^^ + source.ts meta.class.ts meta.type.parameters.ts support.type.builtin.ts +>> { + ^ + source.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> // class content + ^^ + source.ts meta.class.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.class.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.class.ts comment.line.double-slash.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue453.baseline.txt b/tests/baselines/Issue453.baseline.txt new file mode 100644 index 00000000..52e54894 --- /dev/null +++ b/tests/baselines/Issue453.baseline.txt @@ -0,0 +1,208 @@ +original file +----------------------------------- +type Resolve = () => number; + +class Test { + first(values: Map): number { + return values.has('a') ? values.get('a')!() : 0; + } + + second(): string { + return 'foo'; + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>type Resolve = () => number; + ^^^^ + source.ts meta.type.declaration.ts storage.type.type.ts + ^ + source.ts meta.type.declaration.ts + ^^^^^^^ + source.ts meta.type.declaration.ts entity.name.type.alias.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.type.declaration.ts + ^ + source.ts meta.type.declaration.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.type.declaration.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.type.declaration.ts + ^^ + source.ts meta.type.declaration.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.type.declaration.ts meta.type.function.return.ts + ^^^^^^ + source.ts meta.type.declaration.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>class Test { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> first(values: Map): number { + ^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts + ^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> return values.has('a') ? values.get('a')!() : 0; + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts keyword.operator.definiteassignment.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.class.ts +> second(): string { + ^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.return.type.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> return 'foo'; + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue455.baseline.txt b/tests/baselines/Issue455.baseline.txt new file mode 100644 index 00000000..ddf0f1c7 --- /dev/null +++ b/tests/baselines/Issue455.baseline.txt @@ -0,0 +1,78 @@ +original file +----------------------------------- +func(function () // } +{ + if (false) + return 1 + else + return 2 +}); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>func(function () // } + ^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^ + source.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.function.expression.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.expression.ts + ^^ + source.ts meta.function.expression.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^ + source.ts meta.function.expression.ts comment.line.double-slash.ts +>{ + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> if (false) + ^^^^ + source.ts meta.function.expression.ts meta.block.ts + ^^ + source.ts meta.function.expression.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.function.expression.ts meta.block.ts constant.language.boolean.false.ts + ^ + source.ts meta.function.expression.ts meta.block.ts meta.brace.round.ts +> return 1 + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts constant.numeric.decimal.ts +> else + ^^^^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^ + source.ts meta.function.expression.ts meta.block.ts keyword.control.conditional.ts +> return 2 + ^^^^^^^^ + source.ts meta.function.expression.ts meta.block.ts + ^^^^^^ + source.ts meta.function.expression.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.expression.ts meta.block.ts + ^ + source.ts meta.function.expression.ts meta.block.ts constant.numeric.decimal.ts +>}); + ^ + source.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue458.baseline.txt b/tests/baselines/Issue458.baseline.txt new file mode 100644 index 00000000..fea05e18 --- /dev/null +++ b/tests/baselines/Issue458.baseline.txt @@ -0,0 +1,82 @@ +original file +----------------------------------- +export class Blah { + get () {} +} +const x = { + get () {} +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export class Blah { + ^^^^^^ + source.ts meta.class.ts keyword.control.export.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> get () {} + ^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>const x = { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> get () {} + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue460.baseline.txt b/tests/baselines/Issue460.baseline.txt new file mode 100644 index 00000000..21b93591 --- /dev/null +++ b/tests/baselines/Issue460.baseline.txt @@ -0,0 +1,20 @@ +original file +----------------------------------- +// single-line comment +/* multi-line comment */ +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>// single-line comment + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>/* multi-line comment */ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts \ No newline at end of file diff --git a/tests/baselines/Issue461.baseline.txt b/tests/baselines/Issue461.baseline.txt new file mode 100644 index 00000000..1fa41e03 --- /dev/null +++ b/tests/baselines/Issue461.baseline.txt @@ -0,0 +1,226 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has jsx +class Foo { + renderProgress = () => + x + + render () { + return ( +
+ {!this.state.loaded && this.renderProgress()} +
+ ) + } +} +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has jsx + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx comment.line.double-slash.tsx +>class Foo { + ^^^^^ + source.tsx meta.class.tsx storage.type.class.tsx + ^ + source.tsx meta.class.tsx + ^^^ + source.tsx meta.class.tsx entity.name.type.class.tsx + ^ + source.tsx meta.class.tsx + ^ + source.tsx meta.class.tsx punctuation.definition.block.tsx +> renderProgress = () => + ^^ + source.tsx meta.class.tsx meta.field.declaration.tsx + ^^^^^^^^^^^^^^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.definition.property.tsx entity.name.function.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx + ^^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx storage.type.function.arrow.tsx +> x + ^^^^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^^^^^^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx punctuation.section.embedded.begin.tsx + ^^^^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.language.this.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.object.property.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^^^^^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx support.variable.property.dom.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx meta.tag.attributes.tsx punctuation.section.embedded.end.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.class.tsx meta.field.declaration.tsx meta.arrow.tsx meta.tag.tsx punctuation.definition.tag.end.tsx +> + ^ + source.tsx meta.class.tsx +> render () { + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.definition.method.tsx entity.name.function.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx punctuation.definition.block.tsx +> return ( + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx keyword.control.flow.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.brace.round.tsx +>
+ ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx punctuation.section.embedded.begin.tsx + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.language.this.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.object.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx keyword.operator.ternary.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx string.quoted.single.tsx punctuation.definition.string.begin.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx string.quoted.single.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx keyword.operator.ternary.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.object.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^^^^^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.tag.attributes.tsx punctuation.section.embedded.end.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx punctuation.definition.tag.end.tsx +> {!this.state.loaded && this.renderProgress()} + ^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.begin.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx keyword.operator.logical.tsx + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx variable.language.this.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx variable.other.object.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx punctuation.accessor.tsx + ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx variable.other.property.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx keyword.operator.logical.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx variable.language.this.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^^^^^^^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.function-call.tsx entity.name.function.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.brace.round.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx meta.embedded.expression.tsx meta.brace.round.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx punctuation.section.embedded.end.tsx +>
+ ^^^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx meta.jsx.children.tsx + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.tag.tsx punctuation.definition.tag.end.tsx +> ) + ^^^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx meta.brace.round.tsx +> } + ^^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx + ^ + source.tsx meta.class.tsx meta.method.declaration.tsx meta.block.tsx punctuation.definition.block.tsx +>} + ^ + source.tsx meta.class.tsx punctuation.definition.block.tsx \ No newline at end of file diff --git a/tests/baselines/Issue463.baseline.txt b/tests/baselines/Issue463.baseline.txt new file mode 100644 index 00000000..ed5272e9 --- /dev/null +++ b/tests/baselines/Issue463.baseline.txt @@ -0,0 +1,44 @@ +original file +----------------------------------- +const x = + 1 +if (x) return x +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const x = + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts +> 1 + ^^^^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts +>if (x) return x + ^^ + source.ts keyword.control.conditional.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^^^^^ + source.ts keyword.control.flow.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts \ No newline at end of file diff --git a/tests/baselines/Issue466.baseline.txt b/tests/baselines/Issue466.baseline.txt new file mode 100644 index 00000000..8d1ea205 --- /dev/null +++ b/tests/baselines/Issue466.baseline.txt @@ -0,0 +1,50 @@ +original file +----------------------------------- +function foo(this: number, x: number) { + +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function foo(this: number, x: number) { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts variable.language.this.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts meta.function.ts meta.block.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue468.baseline.txt b/tests/baselines/Issue468.baseline.txt new file mode 100644 index 00000000..773ece9f --- /dev/null +++ b/tests/baselines/Issue468.baseline.txt @@ -0,0 +1,38 @@ +original file +----------------------------------- +({ 'foo\'': 'bar' }) +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>({ 'foo\'': 'bar' }) + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.objectliteral.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts + ^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts constant.character.escape.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts \ No newline at end of file diff --git a/tests/baselines/Issue470.baseline.txt b/tests/baselines/Issue470.baseline.txt new file mode 100644 index 00000000..7fbff111 --- /dev/null +++ b/tests/baselines/Issue470.baseline.txt @@ -0,0 +1,38 @@ +original file +----------------------------------- +var x = await import("./file1"); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>var x = await import("./file1"); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts keyword.control.flow.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts keyword.operator.expression.import.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue471.baseline.txt b/tests/baselines/Issue471.baseline.txt new file mode 100644 index 00000000..b1b42ae0 --- /dev/null +++ b/tests/baselines/Issue471.baseline.txt @@ -0,0 +1,70 @@ +original file +----------------------------------- +const foo = + true || `${'hello'}.txt` + +function syntaxHighlightingIsBroken() { +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const foo = + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts +> true || `${'hello'}.txt` + ^^^^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts constant.language.boolean.true.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts keyword.operator.logical.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.begin.ts + ^^ + source.ts meta.var.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.begin.ts + ^ + source.ts meta.var.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.template.ts meta.template.expression.ts meta.embedded.line.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts string.template.ts meta.template.expression.ts punctuation.definition.template-expression.end.ts + ^^^^ + source.ts meta.var.expr.ts string.template.ts + ^ + source.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.end.ts +> + ^ + source.ts +>function syntaxHighlightingIsBroken() { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue472.baseline.txt b/tests/baselines/Issue472.baseline.txt new file mode 100644 index 00000000..9247be07 --- /dev/null +++ b/tests/baselines/Issue472.baseline.txt @@ -0,0 +1,86 @@ +original file +----------------------------------- +interface I { + bar1: { + quantity: string + }, + bar2: + { + quantity: string + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>interface I { + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> bar1: { + ^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts +> quantity: string + ^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts +> }, + ^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts + ^ + source.ts meta.interface.ts punctuation.separator.comma.ts +> bar2: + ^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts +> { + ^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts +> quantity: string + ^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts +> } + ^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.object.type.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue476.baseline.txt b/tests/baselines/Issue476.baseline.txt new file mode 100644 index 00000000..8f40e9ef --- /dev/null +++ b/tests/baselines/Issue476.baseline.txt @@ -0,0 +1,168 @@ +original file +----------------------------------- +class Bug { + static asdf(o, o2) { + Bug.asdf("", '`') + return { + [ + "a" + ]: + [ + Bug.asdf("", '`') + ] + }; + } + +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Bug { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> static asdf(o, o2) { + ^ + source.ts meta.class.ts + ^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> Bug.asdf("", '`') + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.brace.round.ts +> return { + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts +> [ + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.brace.square.ts +> "a" + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts +> ]: + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts +> [ + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts meta.brace.square.ts +> Bug.asdf("", '`') + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts string.quoted.single.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts meta.brace.round.ts +> ] + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts meta.brace.square.ts +> }; + ^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> + ^^ + source.ts meta.class.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue477.baseline.txt b/tests/baselines/Issue477.baseline.txt new file mode 100644 index 00000000..e3d79442 --- /dev/null +++ b/tests/baselines/Issue477.baseline.txt @@ -0,0 +1,380 @@ +original file +----------------------------------- +function* fn1() {} +function * fn2() {} +function *fn3() {} + +const foo = { + * fn4() {}, + *fn5() {}, + fn6: function*() {}, // Incorrect + fn7: function* () {}, // Incorrect + fn8: function *() {}, +} + +class Bar { + * fn9() {} + *fn10() {} + fn11 = function*() {} // Incorrect + fn12 = function* () {} // Incorrect + fn13 = function *() {} +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function* fn1() {} + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts keyword.generator.asterisk.ts + ^ + source.ts meta.function.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>function * fn2() {} + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts keyword.generator.asterisk.ts + ^ + source.ts meta.function.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>function *fn3() {} + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts keyword.generator.asterisk.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>const foo = { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> * fn4() {}, + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts keyword.generator.asterisk.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> *fn5() {}, + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts keyword.generator.asterisk.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> fn6: function*() {}, // Incorrect + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts keyword.generator.asterisk.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts comment.line.double-slash.ts +> fn7: function* () {}, // Incorrect + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts keyword.generator.asterisk.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts comment.line.double-slash.ts +> fn8: function *() {}, + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts keyword.generator.asterisk.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +>} + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> + ^ + source.ts +>class Bar { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> * fn9() {} + ^^^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts keyword.generator.asterisk.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> *fn10() {} + ^^^^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts keyword.generator.asterisk.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> fn11 = function*() {} // Incorrect + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts keyword.generator.asterisk.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts comment.line.double-slash.ts +> fn12 = function* () {} // Incorrect + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts keyword.generator.asterisk.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts comment.line.double-slash.ts +> fn13 = function *() {} + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts keyword.generator.asterisk.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue478.baseline.txt b/tests/baselines/Issue478.baseline.txt new file mode 100644 index 00000000..18eabe37 --- /dev/null +++ b/tests/baselines/Issue478.baseline.txt @@ -0,0 +1,256 @@ +original file +----------------------------------- +// Before +a = (b: string, c: number) => { + console.log(b, c); +} + +d = (e: string) => ( + f: G +) => { + console.log(e, f); +}; + +// After +a = (b: string, c: number) => { + console.log(b, c); +} +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>// Before + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^^ + source.tsx comment.line.double-slash.tsx +>a = (b: string, c: number) => { + ^ + source.tsx entity.name.function.tsx + ^ + source.tsx + ^ + source.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.arrow.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx + ^^^^^^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx support.type.primitive.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx punctuation.separator.parameter.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx + ^^^^^^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx support.type.primitive.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.arrow.tsx + ^^ + source.tsx meta.arrow.tsx storage.type.function.arrow.tsx + ^ + source.tsx meta.arrow.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx punctuation.definition.block.tsx +> console.log(b, c); + ^^ + source.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^^ + source.tsx meta.arrow.tsx meta.block.tsx meta.function-call.tsx support.class.console.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^ + source.tsx meta.arrow.tsx meta.block.tsx meta.function-call.tsx support.function.console.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx meta.brace.round.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx punctuation.separator.comma.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx meta.brace.round.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx punctuation.terminator.statement.tsx +>} + ^ + source.tsx meta.arrow.tsx meta.block.tsx punctuation.definition.block.tsx +> + ^ + source.tsx +>d = (e: string) => ( + ^ + source.tsx entity.name.function.tsx + ^ + source.tsx + ^ + source.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.arrow.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx + ^^^^^^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx support.type.primitive.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.arrow.tsx + ^^ + source.tsx meta.arrow.tsx storage.type.function.arrow.tsx + ^ + source.tsx meta.arrow.tsx + ^ + source.tsx meta.arrow.tsx meta.brace.round.tsx +> f: G + ^^ + source.tsx meta.arrow.tsx + ^ + source.tsx meta.arrow.tsx variable.parameter.tsx + ^ + source.tsx meta.arrow.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.arrow.tsx meta.type.annotation.tsx + ^ + source.tsx meta.arrow.tsx meta.type.annotation.tsx entity.name.type.tsx + ^ + source.tsx meta.arrow.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + ^ + source.tsx meta.arrow.tsx meta.type.annotation.tsx meta.type.parameters.tsx entity.name.type.tsx + ^ + source.tsx meta.arrow.tsx meta.type.annotation.tsx meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx +>) => { + ^ + source.tsx meta.arrow.tsx meta.brace.round.tsx + ^ + source.tsx + ^^ + source.tsx meta.arrow.tsx storage.type.function.arrow.tsx + ^ + source.tsx meta.arrow.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx punctuation.definition.block.tsx +> console.log(e, f); + ^^ + source.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^^ + source.tsx meta.arrow.tsx meta.block.tsx meta.function-call.tsx support.class.console.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^ + source.tsx meta.arrow.tsx meta.block.tsx meta.function-call.tsx support.function.console.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx meta.brace.round.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx punctuation.separator.comma.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx meta.brace.round.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx punctuation.terminator.statement.tsx +>}; + ^ + source.tsx meta.arrow.tsx meta.block.tsx punctuation.definition.block.tsx + ^ + source.tsx punctuation.terminator.statement.tsx +> + ^ + source.tsx +>// After + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^ + source.tsx comment.line.double-slash.tsx +>a = (b: string, c: number) => { + ^ + source.tsx entity.name.function.tsx + ^ + source.tsx + ^ + source.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.arrow.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.begin.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx + ^^^^^^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx support.type.primitive.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx punctuation.separator.parameter.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx variable.parameter.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx keyword.operator.type.annotation.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx + ^^^^^^ + source.tsx meta.arrow.tsx meta.parameters.tsx meta.type.annotation.tsx support.type.primitive.tsx + ^ + source.tsx meta.arrow.tsx meta.parameters.tsx punctuation.definition.parameters.end.tsx + ^ + source.tsx meta.arrow.tsx + ^^ + source.tsx meta.arrow.tsx storage.type.function.arrow.tsx + ^ + source.tsx meta.arrow.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx punctuation.definition.block.tsx +> console.log(b, c); + ^^ + source.tsx meta.arrow.tsx meta.block.tsx + ^^^^^^^ + source.tsx meta.arrow.tsx meta.block.tsx meta.function-call.tsx support.class.console.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx meta.function-call.tsx punctuation.accessor.tsx + ^^^ + source.tsx meta.arrow.tsx meta.block.tsx meta.function-call.tsx support.function.console.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx meta.brace.round.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx punctuation.separator.comma.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx meta.brace.round.tsx + ^ + source.tsx meta.arrow.tsx meta.block.tsx punctuation.terminator.statement.tsx +>} + ^ + source.tsx meta.arrow.tsx meta.block.tsx punctuation.definition.block.tsx \ No newline at end of file diff --git a/tests/baselines/Issue480.baseline.txt b/tests/baselines/Issue480.baseline.txt new file mode 100644 index 00000000..5654bf28 --- /dev/null +++ b/tests/baselines/Issue480.baseline.txt @@ -0,0 +1,130 @@ +original file +----------------------------------- +/* @internal */ +export interface Pattern { + prefix: string; + suffix: string; +} + +// @internal +export interface Pattern2 { + prefix: string; + suffix: string; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/* @internal */ + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^ + source.ts comment.block.ts storage.type.internaldeclaration.ts punctuation.decorator.internaldeclaration.ts + ^^^^^^^^ + source.ts comment.block.ts storage.type.internaldeclaration.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts +>export interface Pattern { + ^^^^^^ + source.ts meta.interface.ts keyword.control.export.ts + ^ + source.ts meta.interface.ts + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> prefix: string; + ^^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +> suffix: string; + ^^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> + ^ + source.ts +>// @internal + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^ + source.ts comment.line.double-slash.ts + ^ + source.ts comment.line.double-slash.ts storage.type.internaldeclaration.ts punctuation.decorator.internaldeclaration.ts + ^^^^^^^^ + source.ts comment.line.double-slash.ts storage.type.internaldeclaration.ts +>export interface Pattern2 { + ^^^^^^ + source.ts meta.interface.ts keyword.control.export.ts + ^ + source.ts meta.interface.ts + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^^^^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> prefix: string; + ^^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +> suffix: string; + ^^^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue482.baseline.txt b/tests/baselines/Issue482.baseline.txt new file mode 100644 index 00000000..64a2d961 --- /dev/null +++ b/tests/baselines/Issue482.baseline.txt @@ -0,0 +1,64 @@ +original file +----------------------------------- +let a = 1; +let b = [new Object] +let c = 1 +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let a = 1; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +>let b = [new Object] + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts + ^^^ + source.ts meta.var.expr.ts meta.array.literal.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts new.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.array.literal.ts new.expr.ts support.class.builtin.ts + ^ + source.ts meta.var.expr.ts meta.array.literal.ts meta.brace.square.ts +>let c = 1 + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts \ No newline at end of file diff --git a/tests/baselines/Issue484.baseline.txt b/tests/baselines/Issue484.baseline.txt new file mode 100644 index 00000000..313fc7e4 --- /dev/null +++ b/tests/baselines/Issue484.baseline.txt @@ -0,0 +1,90 @@ +original file +----------------------------------- +declare module 'foo'; +declare module 'bar'; +declare module 'baz'; +interface Foo { + bar: string; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>declare module 'foo'; + ^^^^^^^ + source.ts meta.namespace.declaration.ts storage.modifier.ts + ^ + source.ts meta.namespace.declaration.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts storage.type.namespace.ts + ^ + source.ts meta.namespace.declaration.ts + ^ + source.ts meta.namespace.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.namespace.declaration.ts string.quoted.single.ts + ^ + source.ts meta.namespace.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>declare module 'bar'; + ^^^^^^^ + source.ts meta.namespace.declaration.ts storage.modifier.ts + ^ + source.ts meta.namespace.declaration.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts storage.type.namespace.ts + ^ + source.ts meta.namespace.declaration.ts + ^ + source.ts meta.namespace.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.namespace.declaration.ts string.quoted.single.ts + ^ + source.ts meta.namespace.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>declare module 'baz'; + ^^^^^^^ + source.ts meta.namespace.declaration.ts storage.modifier.ts + ^ + source.ts meta.namespace.declaration.ts + ^^^^^^ + source.ts meta.namespace.declaration.ts storage.type.namespace.ts + ^ + source.ts meta.namespace.declaration.ts + ^ + source.ts meta.namespace.declaration.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.namespace.declaration.ts string.quoted.single.ts + ^ + source.ts meta.namespace.declaration.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts punctuation.terminator.statement.ts +>interface Foo { + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> bar: string; + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue485.baseline.txt b/tests/baselines/Issue485.baseline.txt new file mode 100644 index 00000000..80802cfa --- /dev/null +++ b/tests/baselines/Issue485.baseline.txt @@ -0,0 +1,52 @@ +original file +----------------------------------- +import a from 'a' // test +import b from 'b' +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>import a from 'a' // test + ^^^^^^ + source.ts meta.import.ts keyword.control.import.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts variable.other.readwrite.alias.ts + ^ + source.ts meta.import.ts + ^^^^ + source.ts meta.import.ts keyword.control.from.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.import.ts string.quoted.single.ts + ^ + source.ts meta.import.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.import.ts + ^^ + source.ts meta.import.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^ + source.ts meta.import.ts comment.line.double-slash.ts +>import b from 'b' + ^^^^^^ + source.ts meta.import.ts keyword.control.import.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts variable.other.readwrite.alias.ts + ^ + source.ts meta.import.ts + ^^^^ + source.ts meta.import.ts keyword.control.from.ts + ^ + source.ts meta.import.ts + ^ + source.ts meta.import.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.import.ts string.quoted.single.ts + ^ + source.ts meta.import.ts string.quoted.single.ts punctuation.definition.string.end.ts \ No newline at end of file diff --git a/tests/baselines/Issue486.baseline.txt b/tests/baselines/Issue486.baseline.txt new file mode 100644 index 00000000..3ee56ea3 --- /dev/null +++ b/tests/baselines/Issue486.baseline.txt @@ -0,0 +1,56 @@ +original file +----------------------------------- +const C = class { + private data = 0; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const C = class { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.var.expr.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.class.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.class.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.var.expr.ts meta.class.ts + ^ + source.ts meta.var.expr.ts meta.class.ts punctuation.definition.block.ts +> private data = 0; + ^^^^ + source.ts meta.var.expr.ts meta.class.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.var.expr.ts meta.class.ts meta.field.declaration.ts + ^^^^ + source.ts meta.var.expr.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.var.expr.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.var.expr.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.var.expr.ts meta.class.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.class.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.var.expr.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue491.baseline.txt b/tests/baselines/Issue491.baseline.txt new file mode 100644 index 00000000..2b15da73 --- /dev/null +++ b/tests/baselines/Issue491.baseline.txt @@ -0,0 +1,108 @@ +original file +----------------------------------- +let a: number = w, +b: string = x, // string is not colored +c: any = y, // any is not colored +d: boolean = z; // boolean is not colored +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let a: number = w, + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts +>b: string = x, // string is not colored + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts comment.line.double-slash.ts +>c: any = y, // any is not colored + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts comment.line.double-slash.ts +>d: boolean = z; // boolean is not colored + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.type.annotation.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts \ No newline at end of file diff --git a/tests/baselines/Issue496.baseline.txt b/tests/baselines/Issue496.baseline.txt new file mode 100644 index 00000000..70a23dd2 --- /dev/null +++ b/tests/baselines/Issue496.baseline.txt @@ -0,0 +1,86 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has cast expression +var x = 0; +var y = 1; +var z = x + y; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has cast expression + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>var x = 0; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +>var y = 1; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +>var z = x + y; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts meta.var.expr.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts meta.var.expr.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue499.baseline.txt b/tests/baselines/Issue499.baseline.txt new file mode 100644 index 00000000..21b3add3 --- /dev/null +++ b/tests/baselines/Issue499.baseline.txt @@ -0,0 +1,76 @@ +original file +----------------------------------- +const fn = ({ + arg = [], +}) => { + return "This line should be highlighted correctly"; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const fn = ({ + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> arg = [], + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +>}) => { + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> return "This line should be highlighted correctly"; + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue5.baseline.txt b/tests/baselines/Issue5.baseline.txt new file mode 100644 index 00000000..f43eb21b --- /dev/null +++ b/tests/baselines/Issue5.baseline.txt @@ -0,0 +1,336 @@ +original file +----------------------------------- +let new_string = "New Changes" + + +let plain_double_text = "Hello\ +this link to github is https://github.com/\ +hello\ +World" + +let plain_single_text= 'Try with single bracket\ +hello world \\\\\ +let this be ^\ +a good test ^' + +let double_quote_issue = " qstring-double:\ + name: string.double.ts\ + begin: \'\"\'\ + end: \'\"|(?:[^\r\n\\]$)'\ + patterns:\ + - include: '#string-character-escape'\ + " + +let single_quote_issue = 'qstring-single:\ + name: string.single.ts\ + begin: \"\'\"\ + end: \'|(?:[^\r\n\\]$)\ + endCaptures:\ + '0': {name: string-character-escape }\ + patterns:\ + - include: \'#string-character-escape\'\ + ' + +let new_string = "Changes End here" + + + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let new_string = "New Changes" + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts +> + ^ + source.ts +> + ^ + source.ts +>let plain_double_text = "Hello\ + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts +>this link to github is https://github.com/\ + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts +>hello\ + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts +>World" + ^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts +> + ^ + source.ts +>let plain_single_text= 'Try with single bracket\ + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts +>hello world \\\\\ + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts + ^^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts +>let this be ^\ + ^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts +>a good test ^' + ^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts +> + ^ + source.ts +>let double_quote_issue = " qstring-double:\ + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts +> name: string.double.ts\ + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts +> begin: \'\"\'\ + ^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts + ^^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts + ^^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts +> end: \'\"|(?:[^\r\n\\]$)'\ + ^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts + ^^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts + ^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts + ^^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts + ^^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts + ^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts +> patterns:\ + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts +> - include: '#string-character-escape'\ + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts constant.character.escape.ts +> " + ^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts +> + ^ + source.ts +>let single_quote_issue = 'qstring-single:\ + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts +> name: string.single.ts\ + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts +> begin: \"\'\"\ + ^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts + ^^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts + ^^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts +> end: \'|(?:[^\r\n\\]$)\ + ^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts + ^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts + ^^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts + ^^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts + ^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts +> endCaptures:\ + ^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts +> '0': {name: string-character-escape }\ + ^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts +> patterns:\ + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts +> - include: \'#string-character-escape\'\ + ^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts constant.character.escape.ts +> ' + ^^^^ + source.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts +> + ^ + source.ts +>let new_string = "Changes End here" + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts +> + ^ + source.ts +> + ^ + source.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue5.txt b/tests/baselines/Issue5.txt deleted file mode 100644 index 5fff9547..00000000 --- a/tests/baselines/Issue5.txt +++ /dev/null @@ -1,43 +0,0 @@ -[1, 18]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[1, 19]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[2, 1]: source.ts -[5, 23]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[6, 6]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts constant.character.escape -[9, 24]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[10, 13]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts constant.character.escape -[14, 28]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[15, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[15, 11]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[15, 27]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts constant.character.escape -[16, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[16, 12]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts constant.character.escape -[17, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[17, 10]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts constant.character.escape -[18, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[18, 14]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts constant.character.escape -[19, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[19, 16]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[19, 42]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts constant.character.escape -[20, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[21, 1]: source.ts -[22, 27]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[22, 42]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts constant.character.escape -[23, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[23, 27]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts constant.character.escape -[24, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[25, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[25, 27]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts constant.character.escape -[26, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[26, 17]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts constant.character.escape -[27, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[27, 44]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts constant.character.escape -[28, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[28, 14]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts constant.character.escape -[29, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[29, 44]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts constant.character.escape -[30, 5]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.single.ts -[31, 1]: source.ts -[32, 18]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[32, 19]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[32, 35]: source.ts meta.var.expr.ts meta.var-single-variable.expr.ts string.double.ts -[33, 1]: source.ts \ No newline at end of file diff --git a/tests/baselines/Issue500.baseline.txt b/tests/baselines/Issue500.baseline.txt new file mode 100644 index 00000000..030b1293 --- /dev/null +++ b/tests/baselines/Issue500.baseline.txt @@ -0,0 +1,28 @@ +original file +----------------------------------- +0 as any as string; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>0 as any as string; + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts + ^^ + source.ts keyword.control.as.ts + ^ + source.ts + ^^^ + source.ts support.type.primitive.ts + ^ + source.ts + ^^ + source.ts keyword.control.as.ts + ^ + source.ts + ^^^^^^ + source.ts support.type.primitive.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue502.baseline.txt b/tests/baselines/Issue502.baseline.txt new file mode 100644 index 00000000..a673568c --- /dev/null +++ b/tests/baselines/Issue502.baseline.txt @@ -0,0 +1,90 @@ +original file +----------------------------------- +class Foo { + bar () { + [...this.foobar()]; + [... this.foobar()]; + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Foo { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> bar () { + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.definition.method.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> [...this.foobar()]; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts keyword.operator.spread.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> [... this.foobar()]; + ^^^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts keyword.operator.spread.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.class.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue506.baseline.txt b/tests/baselines/Issue506.baseline.txt new file mode 100644 index 00000000..7870e2a1 --- /dev/null +++ b/tests/baselines/Issue506.baseline.txt @@ -0,0 +1,216 @@ +original file +----------------------------------- + if (platform.isWindows) { + this._processReady.then(() => { + if (!this._isDisposed) { + import('vs/workbench/parts/terminal/electron-browser/windowsShellHelper').then((module) => { + this._windowsShellHelper = new module.WindowsShellHelper(this._processId, this._shellLaunchConfig.executable, this, this._xterm); + }); + } + }); + } +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +> if (platform.isWindows) { + ^^^^^^^^ + source.ts + ^^ + source.ts keyword.control.conditional.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts variable.other.property.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> this._processReady.then(() => { + ^^^^^^^^^^^^ + source.ts meta.block.ts + ^^^^ + source.ts meta.block.ts meta.function-call.ts variable.language.this.ts + ^ + source.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^ + source.ts meta.block.ts meta.function-call.ts variable.other.object.property.ts + ^ + source.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts meta.function-call.ts support.function.promise.ts + ^ + source.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.block.ts meta.arrow.ts + ^^ + source.ts meta.block.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.block.ts meta.arrow.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> if (!this._isDisposed) { + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts keyword.operator.logical.ts + ^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> import('vs/workbench/parts/terminal/electron-browser/windowsShellHelper').then((module) => { + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.function-call.ts keyword.operator.expression.import.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.promise.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts + ^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> this._windowsShellHelper = new module.WindowsShellHelper(this._processId, this._shellLaunchConfig.executable, this, this._xterm); + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts + ^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts meta.function-call.ts support.type.object.module.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts variable.other.property.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts variable.other.object.property.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts variable.other.property.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts + ^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts variable.language.this.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts variable.other.property.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> }); + ^^^^^^^^^^^^^^^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^^^^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> }); + ^^^^^^^^^^^^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.block.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^^^^^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue510.baseline.txt b/tests/baselines/Issue510.baseline.txt new file mode 100644 index 00000000..d4f1a016 --- /dev/null +++ b/tests/baselines/Issue510.baseline.txt @@ -0,0 +1,374 @@ +original file +----------------------------------- + // Factory functions + + const createZombie = ({ + status = 1, + width = 10, + height = 10, + xPosition, + yPosition, + color = "green" + }) => ({ + status, + width, + height, + xPosition, + yPosition, + color + }); + + const createHero = ({ + status = 1, + width = 25, + height = 50, + xPosition, + yPosition, + color = "red" + }) => ({ + status, + width, + height, + xPosition, + yPosition, + color + }); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +> // Factory functions + ^^^^ + source.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +> + ^ + source.ts +> const createZombie = ({ + ^^^^ + source.ts + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> status = 1, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> width = 10, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> height = 10, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> xPosition, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> yPosition, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> color = "green" + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts +> }) => ({ + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> status, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> width, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> height, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> xPosition, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> yPosition, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> color + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts +> }); + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +> const createHero = ({ + ^^^^ + source.ts + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> status = 1, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> width = 25, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> height = 50, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> xPosition, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> yPosition, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> color = "red" + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts +> }) => ({ + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> status, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> width, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> height, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> xPosition, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> yPosition, + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> color + ^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts +> }); + ^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue513.baseline.txt b/tests/baselines/Issue513.baseline.txt new file mode 100644 index 00000000..cce57b34 --- /dev/null +++ b/tests/baselines/Issue513.baseline.txt @@ -0,0 +1,22 @@ +original file +----------------------------------- +(/a/u); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>(/a/u); + ^ + source.ts meta.brace.round.ts + ^ + source.ts string.regexp.ts punctuation.definition.string.begin.ts + ^ + source.ts string.regexp.ts + ^ + source.ts string.regexp.ts punctuation.definition.string.end.ts + ^ + source.ts string.regexp.ts keyword.other.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue515.baseline.txt b/tests/baselines/Issue515.baseline.txt new file mode 100644 index 00000000..86ad9738 --- /dev/null +++ b/tests/baselines/Issue515.baseline.txt @@ -0,0 +1,122 @@ +original file +----------------------------------- +/** + * @param {boolean} [settings.debug= - Print getUpdate results in console. + */ +/** + * @param {boolean} [settings.debug=] - Print getUpdate results in console. + */ +/** + * @param {boolean} [settings.debug=1] - Print getUpdate results in console. + */ + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/** + ^^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +> * @param {boolean} [settings.debug= - Print getUpdate results in console. + ^^^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc + ^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.begin.jsdoc + ^^^^^^^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.end.jsdoc + ^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts + ^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts variable.other.jsdoc + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> */ + ^ + source.ts comment.block.documentation.ts + ^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +>/** + ^^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +> * @param {boolean} [settings.debug=] - Print getUpdate results in console. + ^^^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc + ^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.begin.jsdoc + ^^^^^^^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.end.jsdoc + ^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts variable.other.jsdoc punctuation.definition.optional-value.begin.bracket.square.jsdoc + ^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts variable.other.jsdoc + ^ + source.ts comment.block.documentation.ts variable.other.jsdoc keyword.operator.assignment.jsdoc + ^ + source.ts comment.block.documentation.ts variable.other.jsdoc punctuation.definition.optional-value.end.bracket.square.jsdoc + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> */ + ^ + source.ts comment.block.documentation.ts + ^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +>/** + ^^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +> * @param {boolean} [settings.debug=1] - Print getUpdate results in console. + ^^^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc punctuation.definition.block.tag.jsdoc + ^^^^^ + source.ts comment.block.documentation.ts storage.type.class.jsdoc + ^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.begin.jsdoc + ^^^^^^^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc + ^ + source.ts comment.block.documentation.ts entity.name.type.instance.jsdoc punctuation.definition.bracket.curly.end.jsdoc + ^ + source.ts comment.block.documentation.ts + ^ + source.ts comment.block.documentation.ts variable.other.jsdoc punctuation.definition.optional-value.begin.bracket.square.jsdoc + ^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts variable.other.jsdoc + ^ + source.ts comment.block.documentation.ts variable.other.jsdoc keyword.operator.assignment.jsdoc + ^ + source.ts comment.block.documentation.ts variable.other.jsdoc source.embedded.ts + ^ + source.ts comment.block.documentation.ts variable.other.jsdoc punctuation.definition.optional-value.end.bracket.square.jsdoc + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.block.documentation.ts +> */ + ^ + source.ts comment.block.documentation.ts + ^^ + source.ts comment.block.documentation.ts punctuation.definition.comment.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue518.baseline.txt b/tests/baselines/Issue518.baseline.txt new file mode 100644 index 00000000..86ba72ca --- /dev/null +++ b/tests/baselines/Issue518.baseline.txt @@ -0,0 +1,136 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has jsx +(= 2 && i < 3 ? "first branch" : i > (j - 2) * 4 ? "second branch" : "third branch" } />) +----------------------------------- + +Grammar: TypeScriptReact.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has jsx + ^^ + source.tsx comment.line.double-slash.tsx punctuation.definition.comment.tsx + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.tsx comment.line.double-slash.tsx +>(= 2 && i < 3 ? "first branch" : i > (j - 2) * 4 ? "second branch" : "third branch" } />) + ^ + source.tsx meta.brace.round.tsx + ^ + source.tsx meta.tag.tsx punctuation.definition.tag.begin.tsx + ^ + source.tsx meta.tag.tsx entity.name.tag.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^^^^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx entity.other.attribute-name.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx keyword.operator.assignment.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx punctuation.section.embedded.begin.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx keyword.operator.relational.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx constant.numeric.decimal.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx keyword.operator.logical.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx keyword.operator.relational.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx constant.numeric.decimal.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx keyword.operator.ternary.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx string.quoted.double.tsx punctuation.definition.string.begin.tsx + ^^^^^^^^^^^^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx string.quoted.double.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx string.quoted.double.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx keyword.operator.ternary.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx keyword.operator.relational.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx meta.brace.round.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx variable.other.readwrite.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx keyword.operator.arithmetic.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx constant.numeric.decimal.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx meta.brace.round.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx keyword.operator.arithmetic.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx constant.numeric.decimal.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx keyword.operator.ternary.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx string.quoted.double.tsx punctuation.definition.string.begin.tsx + ^^^^^^^^^^^^^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx string.quoted.double.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx string.quoted.double.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx keyword.operator.ternary.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx string.quoted.double.tsx punctuation.definition.string.begin.tsx + ^^^^^^^^^^^^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx string.quoted.double.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx string.quoted.double.tsx punctuation.definition.string.end.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx meta.embedded.expression.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx punctuation.section.embedded.end.tsx + ^ + source.tsx meta.tag.tsx meta.tag.attributes.tsx + ^^ + source.tsx meta.tag.tsx punctuation.definition.tag.end.tsx + ^ + source.tsx meta.brace.round.tsx \ No newline at end of file diff --git a/tests/baselines/Issue521.baseline.txt b/tests/baselines/Issue521.baseline.txt new file mode 100644 index 00000000..ea3e3ef7 --- /dev/null +++ b/tests/baselines/Issue521.baseline.txt @@ -0,0 +1,96 @@ +original file +----------------------------------- +const names = results.f(result.success ? (2) : 2).f(c => c.name) +const a = 1; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const names = results.f(result.success ? (2) : 2).f(c => c.name) + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.ternary.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts punctuation.accessor.ts + ^^^^ + source.ts meta.var.expr.ts support.variable.property.dom.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts +>const a = 1; + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue522.baseline.txt b/tests/baselines/Issue522.baseline.txt new file mode 100644 index 00000000..cffd4320 --- /dev/null +++ b/tests/baselines/Issue522.baseline.txt @@ -0,0 +1,230 @@ +original file +----------------------------------- +const brokenSyntaxHighlighting = () => { + const array = a?.b?.c?.d?.g; + + /** + * No TypeEror, but syntax highlighting is broken + */ + const test = a?.b?.f?.f; + + for (let i = 0; i < array.length; i++) { + console.log(array[i]); + } +}; + +brokenSyntaxHighlighting(); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const brokenSyntaxHighlighting = () => { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> const array = a?.b?.c?.d?.g; + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.optional.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.object.property.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.optional.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.object.property.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.optional.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.object.property.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.optional.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts +> /** + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts comment.block.documentation.ts punctuation.definition.comment.ts +> * No TypeEror, but syntax highlighting is broken + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts comment.block.documentation.ts +> */ + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts comment.block.documentation.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts comment.block.documentation.ts punctuation.definition.comment.ts +> const test = a?.b?.f?.f; + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.object.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.optional.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.object.property.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.optional.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.object.property.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.accessor.optional.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.property.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts +> for (let i = 0; i < array.length; i++) { + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts keyword.control.loop.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts support.variable.property.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts keyword.operator.increment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> console.log(array[i]); + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts meta.function-call.ts support.class.console.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts meta.function-call.ts support.function.console.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +>}; + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>brokenSyntaxHighlighting(); + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue525.baseline.txt b/tests/baselines/Issue525.baseline.txt new file mode 100644 index 00000000..9c3ba0cd --- /dev/null +++ b/tests/baselines/Issue525.baseline.txt @@ -0,0 +1,80 @@ +original file +----------------------------------- +map(result.success ? (a) : 1).map(c => c.name) +const a = 1; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>map(result.success ? (a) : 1).map(c => c.name) + ^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^^^^^^ + source.ts variable.other.property.ts + ^ + source.ts + ^ + source.ts keyword.operator.ternary.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts keyword.operator.ternary.ts + ^ + source.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts variable.other.object.ts + ^ + source.ts punctuation.accessor.ts + ^^^^ + source.ts support.variable.property.dom.ts + ^ + source.ts meta.brace.round.ts +>const a = 1; + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue526.baseline.txt b/tests/baselines/Issue526.baseline.txt new file mode 100644 index 00000000..55115fc0 --- /dev/null +++ b/tests/baselines/Issue526.baseline.txt @@ -0,0 +1,68 @@ +original file +----------------------------------- +if (a++ < b) { +} + +export class A extends B { +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>if (a++ < b) { + ^^ + source.ts keyword.control.conditional.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts variable.other.readwrite.ts + ^^ + source.ts keyword.operator.increment.ts + ^ + source.ts + ^ + source.ts keyword.operator.relational.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>export class A extends B { + ^^^^^^ + source.ts meta.class.ts keyword.control.export.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue530.baseline.txt b/tests/baselines/Issue530.baseline.txt new file mode 100644 index 00000000..7feb4d67 --- /dev/null +++ b/tests/baselines/Issue530.baseline.txt @@ -0,0 +1,114 @@ +original file +----------------------------------- +function getStats() { + const query = query<[number], number>(` + SELECT * + FROM statistics + WHERE unit_id = $1`) + + return database.execute(query, [id]) +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function getStats() { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> const query = query<[number], number>(` + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.begin.ts +> SELECT * + ^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts string.template.ts +> FROM statistics + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts string.template.ts +> WHERE unit_id = $1`) + ^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts string.template.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts +> + ^ + source.ts meta.function.ts meta.block.ts +> return database.execute(query, [id]) + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue531.baseline.txt b/tests/baselines/Issue531.baseline.txt new file mode 100644 index 00000000..219bbdbc --- /dev/null +++ b/tests/baselines/Issue531.baseline.txt @@ -0,0 +1,50 @@ +original file +----------------------------------- +class Test { } +export { + Test as default +}; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Test { } + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>export { + ^^^^^^ + source.ts meta.export.ts keyword.control.export.ts + ^ + source.ts meta.export.ts + ^ + source.ts meta.export.ts meta.block.ts punctuation.definition.block.ts +> Test as default + ^ + source.ts meta.export.ts meta.block.ts + ^^^^ + source.ts meta.export.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.export.ts meta.block.ts + ^^ + source.ts meta.export.ts meta.block.ts keyword.control.as.ts + ^ + source.ts meta.export.ts meta.block.ts + ^^^^^^^ + source.ts meta.export.ts meta.block.ts keyword.control.default.ts +>}; + ^ + source.ts meta.export.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue536.baseline.txt b/tests/baselines/Issue536.baseline.txt new file mode 100644 index 00000000..b17b4380 --- /dev/null +++ b/tests/baselines/Issue536.baseline.txt @@ -0,0 +1,42 @@ +original file +----------------------------------- +const z = (() => {})() +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const z = (() => {})() + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts \ No newline at end of file diff --git a/tests/baselines/Issue538.baseline.txt b/tests/baselines/Issue538.baseline.txt new file mode 100644 index 00000000..35547940 --- /dev/null +++ b/tests/baselines/Issue538.baseline.txt @@ -0,0 +1,84 @@ +original file +----------------------------------- +declare function f(): void; +const x = f<"a", "b">(); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>declare function f(): void; + ^^^^^^^ + source.ts meta.function.ts storage.modifier.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.function.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.type.parameters.ts + ^ + source.ts meta.function.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^^^ + source.ts meta.function.ts meta.return.type.ts support.type.primitive.ts + ^ + source.ts punctuation.terminator.statement.ts +>const x = f<"a", "b">(); + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue540.baseline.txt b/tests/baselines/Issue540.baseline.txt new file mode 100644 index 00000000..48b47429 --- /dev/null +++ b/tests/baselines/Issue540.baseline.txt @@ -0,0 +1,578 @@ +original file +----------------------------------- +// 1. Correct highlighting +doSomething = (param, { a = "default" } = {}) => { + //noop +} + +// 2. Incorrect highlighting - limitation of grammar +doSomething = (param, { + a = "default" +} = {}) => { + //noop +} + +// 3. Correct highlighting +doSomething(param, { + a = "default" +} = {}) { + //noop +} + +// 4. Correct highlighting +doSomething(param, { a = "default" } = {}) { + //noop +} + +// 5. Correct highlighting (notice config module) +doSomething(param, { + a = config.get("a") +} = {}) { + //noop +} + +// 6. Correct highlighting (notice config module) +doSomething(param, { a = config.get("a") } = {}) { + //noop +} + +// 7. Incorrect highlighting (notice config module) while 1. does +doSomething = (param, { a = config.get("a") } = {}) => { + //noop +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>// 1. Correct highlighting + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>doSomething = (param, { a = "default" } = {}) => { + ^^^^^^^^^^^ + source.ts entity.name.function.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts punctuation.definition.binding-pattern.object.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts keyword.operator.assignment.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts string.quoted.double.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts punctuation.definition.binding-pattern.object.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts keyword.operator.assignment.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> //noop + ^^^^ + source.ts meta.arrow.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.arrow.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^ + source.ts meta.arrow.ts meta.block.ts comment.line.double-slash.ts +>} + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>// 2. Incorrect highlighting - limitation of grammar + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>doSomething = (param, { + ^^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^^ + source.ts meta.objectliteral.ts +> a = "default" + ^^^^ + source.ts meta.objectliteral.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts +>} = {}) => { + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> //noop + ^^^^ + source.ts meta.arrow.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.arrow.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^ + source.ts meta.arrow.ts meta.block.ts comment.line.double-slash.ts +>} + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>// 3. Correct highlighting + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>doSomething(param, { + ^^^^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts +> a = "default" + ^^^^ + source.ts meta.objectliteral.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts +>} = {}) { + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> //noop + ^^^^ + source.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^ + source.ts meta.block.ts comment.line.double-slash.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>// 4. Correct highlighting + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>doSomething(param, { a = "default" } = {}) { + ^^^^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.objectliteral.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> //noop + ^^^^ + source.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^ + source.ts meta.block.ts comment.line.double-slash.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>// 5. Correct highlighting (notice config module) + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>doSomething(param, { + ^^^^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts +> a = config.get("a") + ^^^^ + source.ts meta.objectliteral.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts +>} = {}) { + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> //noop + ^^^^ + source.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^ + source.ts meta.block.ts comment.line.double-slash.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>// 6. Correct highlighting (notice config module) + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>doSomething(param, { a = config.get("a") } = {}) { + ^^^^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.brace.round.ts + ^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.separator.comma.ts + ^ + source.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.objectliteral.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.assignment.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^^^^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> //noop + ^^^^ + source.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^ + source.ts meta.block.ts comment.line.double-slash.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>// 7. Incorrect highlighting (notice config module) while 1. does + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>doSomething = (param, { a = config.get("a") } = {}) => { + ^^^^^^^^^^^ + source.ts entity.name.function.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^ + source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts punctuation.definition.binding-pattern.object.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts keyword.operator.assignment.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts + ^^^^^^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts meta.function-call.ts punctuation.accessor.ts + ^^^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts meta.function-call.ts support.function.dom.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts string.quoted.double.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts meta.brace.round.ts + ^^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.parameter.object-binding-pattern.ts punctuation.definition.binding-pattern.object.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts keyword.operator.assignment.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> //noop + ^^^^ + source.ts meta.arrow.ts meta.block.ts punctuation.whitespace.comment.leading.ts + ^^ + source.ts meta.arrow.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^ + source.ts meta.arrow.ts meta.block.ts comment.line.double-slash.ts +>} + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue543.baseline.txt b/tests/baselines/Issue543.baseline.txt new file mode 100644 index 00000000..948af715 --- /dev/null +++ b/tests/baselines/Issue543.baseline.txt @@ -0,0 +1,182 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has cast +let x = -5; +x = --x; +x = +x; +1 && 2 & 3 | 4 + 5 ^ 6 && (5) +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has cast + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>let x = -5; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^^^ + source.ts meta.var.expr.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +>x = --x; + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +>x = +x; + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.assignment.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +>1 && 2 & 3 | 4 + 5 ^ 6 && (5) + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts + ^^ + source.ts keyword.operator.logical.ts + ^ + source.ts cast.expr.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts + ^ + source.ts keyword.operator.bitwise.ts + ^ + source.ts cast.expr.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts + ^ + source.ts keyword.operator.bitwise.ts + ^ + source.ts cast.expr.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts cast.expr.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts + ^ + source.ts keyword.operator.bitwise.ts + ^ + source.ts cast.expr.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts + ^^ + source.ts keyword.operator.logical.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts cast.expr.ts support.type.primitive.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts meta.brace.round.ts \ No newline at end of file diff --git a/tests/baselines/Issue549.baseline.txt b/tests/baselines/Issue549.baseline.txt new file mode 100644 index 00000000..4164c8e2 --- /dev/null +++ b/tests/baselines/Issue549.baseline.txt @@ -0,0 +1,100 @@ +original file +----------------------------------- +function foo(x, y){ + if(x < y || (x > (y))){ + } + return 'of the jedi'; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function foo(x, y){ + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> if(x < y || (x > (y))){ + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> } + ^^^^ + source.ts meta.function.ts meta.block.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> return 'of the jedi'; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts string.quoted.single.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue550.baseline.txt b/tests/baselines/Issue550.baseline.txt new file mode 100644 index 00000000..8d1f4b9d --- /dev/null +++ b/tests/baselines/Issue550.baseline.txt @@ -0,0 +1,180 @@ +original file +----------------------------------- +export const foo = (firstVariable: string, secondVariable: number): string => { + return "foo" +} + +export const bar = ( + firstVariable: string, + secondVariable: number, + thirdVariable: string +): string => { + return "baz" +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export const foo = (firstVariable: string, secondVariable: number): string => { + ^^^^^^ + source.ts meta.var.expr.ts keyword.control.export.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts + ^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> return "foo" + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts +>} + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>export const bar = ( + ^^^^^^ + source.ts meta.var.expr.ts keyword.control.export.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts +> firstVariable: string, + ^^^^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.parameter.ts +> secondVariable: number, + ^^^^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.parameter.ts +> thirdVariable: string + ^^^^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.type.annotation.ts support.type.primitive.ts +>): string => { + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> return "baz" + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts +>} + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue551.baseline.txt b/tests/baselines/Issue551.baseline.txt new file mode 100644 index 00000000..500182c2 --- /dev/null +++ b/tests/baselines/Issue551.baseline.txt @@ -0,0 +1,70 @@ +original file +----------------------------------- +class a extends b, c { +} +class a2 extends b, c +{ +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class a extends b, c { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^^ + source.ts meta.class.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +>class a2 extends b, c + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts storage.modifier.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.other.inherited-class.ts + ^ + source.ts meta.class.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts entity.other.inherited-class.ts +>{ + ^ + source.ts meta.class.ts punctuation.definition.block.ts + ^^ + source.ts meta.class.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue554.baseline.txt b/tests/baselines/Issue554.baseline.txt new file mode 100644 index 00000000..abcc6bed --- /dev/null +++ b/tests/baselines/Issue554.baseline.txt @@ -0,0 +1,130 @@ +original file +----------------------------------- +async function f(x: Promise) { + return { ...await x }; +} +...new Object() +...function f() {} +...typeof x +...void x +...undefined +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>async function f(x: Promise) { + ^^^^^ + source.ts meta.function.ts storage.modifier.async.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts support.type.builtin.ts + ^ + source.ts meta.function.ts meta.parameters.ts meta.type.annotation.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> return { ...await x }; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts + ^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts keyword.operator.spread.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.function.ts meta.block.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>...new Object() + ^^^ + source.ts keyword.operator.spread.ts + ^^^ + source.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts new.expr.ts + ^^^^^^ + source.ts new.expr.ts meta.function-call.ts support.class.builtin.ts + ^ + source.ts new.expr.ts meta.brace.round.ts + ^ + source.ts new.expr.ts meta.brace.round.ts +>...function f() {} + ^^^ + source.ts keyword.operator.spread.ts + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>...typeof x + ^^^ + source.ts keyword.operator.spread.ts + ^^^^^^ + source.ts keyword.operator.expression.typeof.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts +>...void x + ^^^ + source.ts keyword.operator.spread.ts + ^^^^ + source.ts keyword.operator.expression.void.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts +>...undefined + ^^^ + source.ts keyword.operator.spread.ts + ^^^^^^^^^ + source.ts constant.language.undefined.ts \ No newline at end of file diff --git a/tests/baselines/Issue556.baseline.txt b/tests/baselines/Issue556.baseline.txt new file mode 100644 index 00000000..b63f9df7 --- /dev/null +++ b/tests/baselines/Issue556.baseline.txt @@ -0,0 +1,88 @@ +original file +----------------------------------- +class Thing { + foo: SomeFunc = () => void 0; + bar = () => void 0; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>class Thing { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> foo: SomeFunc = () => void 0; + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts entity.name.type.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.expression.void.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +> bar = () => void 0; + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.arrow.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.expression.void.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue558.baseline.txt b/tests/baselines/Issue558.baseline.txt new file mode 100644 index 00000000..9f059691 --- /dev/null +++ b/tests/baselines/Issue558.baseline.txt @@ -0,0 +1,268 @@ +original file +----------------------------------- +export const interview = async ( + fabricatedCase : FabricatedCase +) : Promise => { + const res = await fetch(API_URL + '/interviews', { + method: 'POST', + headers: new Headers({ + 'Content-Type': 'application/json', + }), + body: JSON.stringify(fabricatedTest), + }); + const interviewTest = await res.json(); + return interviewTest; +}; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export const interview = async ( + ^^^^^^ + source.ts meta.var.expr.ts keyword.control.export.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts storage.modifier.async.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts +> fabricatedCase : FabricatedCase + ^^^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.type.annotation.ts + ^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.type.annotation.ts entity.name.type.ts +>) : Promise => { + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.return.type.arrow.ts + ^^ + source.ts meta.var.expr.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> const res = await fetch(API_URL + '/interviews', { + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.control.flow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> method: 'POST', + ^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> headers: new Headers({ + ^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> 'Content-Type': 'application/json', + ^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.objectliteral.ts meta.object.member.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.objectliteral.ts meta.object.member.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> }), + ^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> body: JSON.stringify(fabricatedTest), + ^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts punctuation.separator.key-value.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts support.constant.json.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.function-call.ts support.function.json.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> }); + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> const interviewTest = await res.json(); + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts keyword.control.flow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> return interviewTest; + ^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +>}; + ^ + source.ts meta.var.expr.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue559.baseline.txt b/tests/baselines/Issue559.baseline.txt new file mode 100644 index 00000000..26c176d0 --- /dev/null +++ b/tests/baselines/Issue559.baseline.txt @@ -0,0 +1,188 @@ +original file +----------------------------------- +let myFunc = function(txt:string,num:number){} + +class MyClass { + myProp = myFunc void>("syntax highlight is incorrect", 1); +} + +let myProp = myFunc void>("syntax highlight is correct here", 1); +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>let myFunc = function(txt:string,num:number){} + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts storage.type.function.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.separator.parameter.ts + ^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.function.expression.ts meta.block.ts punctuation.definition.block.ts +> + ^ + source.ts +>class MyClass { + ^^^^^ + source.ts meta.class.ts storage.type.class.ts + ^ + source.ts meta.class.ts + ^^^^^^^ + source.ts meta.class.ts entity.name.type.class.ts + ^ + source.ts meta.class.ts + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> myProp = myFunc void>("syntax highlight is incorrect", 1); + ^^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.definition.property.ts variable.object.property.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts keyword.operator.assignment.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts + ^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts meta.type.function.return.ts + ^^^^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts punctuation.separator.comma.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts constant.numeric.decimal.ts + ^ + source.ts meta.class.ts meta.field.declaration.ts meta.brace.round.ts + ^ + source.ts meta.class.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.class.ts punctuation.definition.block.ts +> + ^ + source.ts +>let myProp = myFunc void>("syntax highlight is correct here", 1); + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.type.parameters.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts + ^^ + source.ts meta.var.expr.ts meta.type.parameters.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts meta.type.function.return.ts + ^^^^ + source.ts meta.var.expr.ts meta.type.parameters.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts punctuation.separator.comma.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue562.baseline.txt b/tests/baselines/Issue562.baseline.txt new file mode 100644 index 00000000..7df9f5d0 --- /dev/null +++ b/tests/baselines/Issue562.baseline.txt @@ -0,0 +1,240 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has cast +yield 10; +(yield 10); +function foo() { + return 10; +} +topYields.sort ((share1,share2) => { + if (share1.yield < share2.yield) { return 1; } + if (share1.yield > share2.yield) { return -1; } + return 0; + }); + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>// @onlyOwnGrammar - As this has cast + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>yield 10; + ^^^^^ + source.ts keyword.control.flow.ts + ^ + source.ts cast.expr.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts cast.expr.ts entity.name.type.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^^ + source.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts +>(yield 10); + ^ + source.ts meta.brace.round.ts + ^^^^^ + source.ts keyword.control.flow.ts + ^ + source.ts cast.expr.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts cast.expr.ts entity.name.type.ts + ^ + source.ts cast.expr.ts meta.brace.angle.ts + ^^ + source.ts constant.numeric.decimal.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +>function foo() { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> return 10; + ^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts cast.expr.ts + ^ + source.ts meta.function.ts meta.block.ts cast.expr.ts meta.brace.angle.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts cast.expr.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.block.ts cast.expr.ts meta.brace.angle.ts + ^^ + source.ts meta.function.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>topYields.sort ((share1,share2) => { + ^^^^^^^^^ + source.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function-call.ts support.function.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^^^^^^ + source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.separator.parameter.ts + ^^^^^^ + source.ts meta.arrow.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.arrow.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.arrow.ts + ^^ + source.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.arrow.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts +> if (share1.yield < share2.yield) { return 1; } + ^^^^ + source.ts meta.arrow.ts meta.block.ts + ^^ + source.ts meta.arrow.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> if (share1.yield > share2.yield) { return -1; } + ^^^^ + source.ts meta.arrow.ts meta.block.ts + ^^ + source.ts meta.arrow.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts keyword.operator.relational.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.object.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.accessor.ts + ^^^^^ + source.ts meta.arrow.ts meta.block.ts variable.other.property.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts keyword.operator.arithmetic.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> return 0; + ^^^^ + source.ts meta.arrow.ts meta.block.ts + ^^^^^^ + source.ts meta.arrow.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.terminator.statement.ts +> }); + ^^ + source.ts meta.arrow.ts meta.block.ts + ^ + source.ts meta.arrow.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue566.baseline.txt b/tests/baselines/Issue566.baseline.txt new file mode 100644 index 00000000..e3dc9545 --- /dev/null +++ b/tests/baselines/Issue566.baseline.txt @@ -0,0 +1,342 @@ +original file +----------------------------------- +const COULOMB = 8.957_551_787e9; // N-m^2 / C^2 +const PLANCK = 6.626_070_040e-34; // J-s +const JENNY = 867_5309; // C-A-L^2 +let bits = 0b1100_1100; +let routine = 0xC0FFEE_F00D_BED; + +1_000_000_000 +1.1_00_01 +1e1_0 +1e+1_0 +1e-1_0 +1.1e10_0 +1.1e+10_0 +1.1e-10_0 +12_34_56 +1_22_333 +1_2.3_4 +1_2.3_4e5_6 +1_2.3_4e+5_6 +1_2.3_4e-5_6 + +0x00_11; +0X0_1; +0x1100_0011; +0X0_11_0101; + +0o00_11; +0O0_1; +0o1100_0011; +0O0_11_0101; + +0b00_11; +0B0_1; +0b1100_0011; +0B0_11_0101; + +// Verify the following are not classified as a number +_1_2; +0b_1; +0x_1; +0o_1; + +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const COULOMB = 8.957_551_787e9; // N-m^2 / C^2 + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^^^^^^^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>const PLANCK = 6.626_070_040e-34; // J-s + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^ + source.ts comment.line.double-slash.ts +>const JENNY = 867_5309; // C-A-L^2 + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^ + source.ts comment.line.double-slash.ts +>let bits = 0b1100_1100; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^ + source.ts meta.var.expr.ts constant.numeric.binary.ts + ^ + source.ts punctuation.terminator.statement.ts +>let routine = 0xC0FFEE_F00D_BED; + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts constant.numeric.hex.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>1_000_000_000 + ^^^^^^^^^^^^^ + source.ts constant.numeric.decimal.ts +>1.1_00_01 + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^^^^ + source.ts constant.numeric.decimal.ts +>1e1_0 + ^^^^^ + source.ts constant.numeric.decimal.ts +>1e+1_0 + ^^^^^^ + source.ts constant.numeric.decimal.ts +>1e-1_0 + ^^^^^^ + source.ts constant.numeric.decimal.ts +>1.1e10_0 + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^^^ + source.ts constant.numeric.decimal.ts +>1.1e+10_0 + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^^^^ + source.ts constant.numeric.decimal.ts +>1.1e-10_0 + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^^^^ + source.ts constant.numeric.decimal.ts +>12_34_56 + ^^^^^^^^ + source.ts constant.numeric.decimal.ts +>1_22_333 + ^^^^^^^^ + source.ts constant.numeric.decimal.ts +>1_2.3_4 + ^^^ + source.ts constant.numeric.decimal.ts + ^ + source.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^ + source.ts constant.numeric.decimal.ts +>1_2.3_4e5_6 + ^^^ + source.ts constant.numeric.decimal.ts + ^ + source.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^^^^ + source.ts constant.numeric.decimal.ts +>1_2.3_4e+5_6 + ^^^ + source.ts constant.numeric.decimal.ts + ^ + source.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^^^^^ + source.ts constant.numeric.decimal.ts +>1_2.3_4e-5_6 + ^^^ + source.ts constant.numeric.decimal.ts + ^ + source.ts constant.numeric.decimal.ts meta.delimiter.decimal.period.ts + ^^^^^^^^ + source.ts constant.numeric.decimal.ts +> + ^ + source.ts +>0x00_11; + ^^^^^^^ + source.ts constant.numeric.hex.ts + ^ + source.ts punctuation.terminator.statement.ts +>0X0_1; + ^^^^^ + source.ts constant.numeric.hex.ts + ^ + source.ts punctuation.terminator.statement.ts +>0x1100_0011; + ^^^^^^^^^^^ + source.ts constant.numeric.hex.ts + ^ + source.ts punctuation.terminator.statement.ts +>0X0_11_0101; + ^^^^^^^^^^^ + source.ts constant.numeric.hex.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>0o00_11; + ^^^^^^^ + source.ts constant.numeric.octal.ts + ^ + source.ts punctuation.terminator.statement.ts +>0O0_1; + ^^^^^ + source.ts constant.numeric.octal.ts + ^ + source.ts punctuation.terminator.statement.ts +>0o1100_0011; + ^^^^^^^^^^^ + source.ts constant.numeric.octal.ts + ^ + source.ts punctuation.terminator.statement.ts +>0O0_11_0101; + ^^^^^^^^^^^ + source.ts constant.numeric.octal.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>0b00_11; + ^^^^^^^ + source.ts constant.numeric.binary.ts + ^ + source.ts punctuation.terminator.statement.ts +>0B0_1; + ^^^^^ + source.ts constant.numeric.binary.ts + ^ + source.ts punctuation.terminator.statement.ts +>0b1100_0011; + ^^^^^^^^^^^ + source.ts constant.numeric.binary.ts + ^ + source.ts punctuation.terminator.statement.ts +>0B0_11_0101; + ^^^^^^^^^^^ + source.ts constant.numeric.binary.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts +>// Verify the following are not classified as a number + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts +>_1_2; + ^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +>0b_1; + ^ + source.ts + ^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +>0x_1; + ^ + source.ts + ^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +>0o_1; + ^ + source.ts + ^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts punctuation.terminator.statement.ts +> + ^ + source.ts \ No newline at end of file diff --git a/tests/baselines/Issue567.baseline.txt b/tests/baselines/Issue567.baseline.txt new file mode 100644 index 00000000..45012a33 --- /dev/null +++ b/tests/baselines/Issue567.baseline.txt @@ -0,0 +1,478 @@ +original file +----------------------------------- +function t(){ +return e.call(this,[t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),"-",t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),"-","4",t._randomHex(),t._randomHex(),t._randomHex(),"-",t._oneOf(t._timeHighBits),t._randomHex(),t._randomHex(),t._randomHex(),"-",t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex()].join(""))||this} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function t(){ + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>return e.call(this,[t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),"-",t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),"-","4",t._randomHex(),t._randomHex(),t._randomHex(),"-",t._oneOf(t._timeHighBits),t._randomHex(),t._randomHex(),t._randomHex(),"-",t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex()].join(""))||this} + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^ + source.ts meta.function.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.accessor.ts + ^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts variable.other.property.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts support.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.function.ts meta.block.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^ + source.ts meta.function.ts meta.block.ts keyword.operator.logical.ts + ^^^^ + source.ts meta.function.ts meta.block.ts variable.language.this.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue569.baseline.txt b/tests/baselines/Issue569.baseline.txt new file mode 100644 index 00000000..a9218f28 --- /dev/null +++ b/tests/baselines/Issue569.baseline.txt @@ -0,0 +1,56 @@ +original file +----------------------------------- +export { default as x } +export { x as default } +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>export { default as x } + ^^^^^^ + source.ts meta.export.ts keyword.control.export.ts + ^ + source.ts meta.export.ts + ^ + source.ts meta.export.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.export.ts meta.block.ts + ^^^^^^^ + source.ts meta.export.ts meta.block.ts keyword.control.default.ts + ^ + source.ts meta.export.ts meta.block.ts + ^^ + source.ts meta.export.ts meta.block.ts keyword.control.as.ts + ^ + source.ts meta.export.ts meta.block.ts + ^ + source.ts meta.export.ts meta.block.ts variable.other.readwrite.alias.ts + ^ + source.ts meta.export.ts meta.block.ts + ^ + source.ts meta.export.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.export.ts +>export { x as default } + ^^^^^^ + source.ts meta.export.ts keyword.control.export.ts + ^ + source.ts meta.export.ts + ^ + source.ts meta.export.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.export.ts meta.block.ts + ^ + source.ts meta.export.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.export.ts meta.block.ts + ^^ + source.ts meta.export.ts meta.block.ts keyword.control.as.ts + ^ + source.ts meta.export.ts meta.block.ts + ^^^^^^^ + source.ts meta.export.ts meta.block.ts keyword.control.default.ts + ^ + source.ts meta.export.ts meta.block.ts + ^ + source.ts meta.export.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue571.baseline.txt b/tests/baselines/Issue571.baseline.txt new file mode 100644 index 00000000..8b5a4654 --- /dev/null +++ b/tests/baselines/Issue571.baseline.txt @@ -0,0 +1,138 @@ +original file +----------------------------------- +const o = { + ["a" + + "b"]() { + return 0; // no highlighting! + }, + 'a\ + '() { + return 0; // no highlighting! + } +}; +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>const o = { + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts +> ["a" + + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts keyword.operator.arithmetic.ts +> "b"]() { + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.quoted.double.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts string.quoted.double.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> return 0; // no highlighting! + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts comment.line.double-slash.ts +> }, + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.separator.comma.ts +> 'a\ + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts punctuation.definition.string.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts constant.character.escape.ts +> '() { + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.object.member.ts meta.object-literal.key.ts string.quoted.single.ts punctuation.definition.string.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +> return 0; // no highlighting! + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.terminator.statement.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts comment.line.double-slash.ts +> } + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts meta.method.declaration.ts meta.block.ts punctuation.definition.block.ts +>}; + ^ + source.ts meta.var.expr.ts meta.objectliteral.ts punctuation.definition.block.ts + ^ + source.ts punctuation.terminator.statement.ts \ No newline at end of file diff --git a/tests/baselines/Issue572.baseline.txt b/tests/baselines/Issue572.baseline.txt new file mode 100644 index 00000000..ac8e1ce2 --- /dev/null +++ b/tests/baselines/Issue572.baseline.txt @@ -0,0 +1,64 @@ +original file +----------------------------------- +function /*like here*/ * foo() { + yield /*or here*/* [42]; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function /*like here*/ * foo() { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^ + source.ts meta.function.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^^^ + source.ts meta.function.ts comment.block.ts + ^^ + source.ts meta.function.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts keyword.generator.asterisk.ts + ^ + source.ts meta.function.ts + ^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> yield /*or here*/* [42]; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^ + source.ts meta.function.ts meta.block.ts comment.block.ts punctuation.definition.comment.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts comment.block.ts + ^^ + source.ts meta.function.ts meta.block.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.generator.asterisk.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue572ForLoop.baseline.txt b/tests/baselines/Issue572ForLoop.baseline.txt new file mode 100644 index 00000000..3ad2e53b --- /dev/null +++ b/tests/baselines/Issue572ForLoop.baseline.txt @@ -0,0 +1,470 @@ +original file +----------------------------------- +/*0*/ for /*1*/ ( /*2*/ var /*3*/ x /*4*/ in /*5*/ a /*6*/) /*7*/{} +/*0*/ for /*1*/ ( /*2*/ var /*3*/ x /*4*/ of /*5*/ a /*6*/) /*7*/{} +/*0*/ for /*1*/ ( /*3*/ x /*4*/ in /*5*/ a /*6*/) /*7*/ {} +/*0*/ for /*1*/ ( /*3*/ x /*4*/ of /*5*/ a /*6*/) /*7*/ {} +/*0*/ for /*1*/ ( /*2*/ a /*3*/ ; /*4*/ a /*5*/ ; /*6*/ a /*7*/) /*8*/ {} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>/*0*/ for /*1*/ ( /*2*/ var /*3*/ x /*4*/ in /*5*/ a /*6*/) /*7*/{} + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^^^ + source.ts keyword.control.loop.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^^ + source.ts keyword.operator.expression.in.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +>/*0*/ for /*1*/ ( /*2*/ var /*3*/ x /*4*/ of /*5*/ a /*6*/) /*7*/{} + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^^^ + source.ts keyword.control.loop.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.readwrite.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts + ^^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^^ + source.ts keyword.operator.expression.of.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +>/*0*/ for /*1*/ ( /*3*/ x /*4*/ in /*5*/ a /*6*/) /*7*/ {} + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^^^ + source.ts keyword.control.loop.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^^ + source.ts keyword.operator.expression.in.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +>/*0*/ for /*1*/ ( /*3*/ x /*4*/ of /*5*/ a /*6*/) /*7*/ {} + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^^^ + source.ts keyword.control.loop.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^^ + source.ts keyword.operator.expression.of.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +>/*0*/ for /*1*/ ( /*2*/ a /*3*/ ; /*4*/ a /*5*/ ; /*6*/ a /*7*/) /*8*/ {} + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^^^ + source.ts keyword.control.loop.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts comment.block.ts + ^^ + source.ts comment.block.ts punctuation.definition.comment.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue575.baseline.txt b/tests/baselines/Issue575.baseline.txt new file mode 100644 index 00000000..480b1bda --- /dev/null +++ b/tests/baselines/Issue575.baseline.txt @@ -0,0 +1,106 @@ +original file +----------------------------------- +function runQuery() { + const query = createQuery<[number[]], Table>(` + some SQL here + `) + return database.execute(query) +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function runQuery() { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^^^^^^^^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> const query = createQuery<[number[]], Table>(` + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts + ^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts meta.type.tuple.ts meta.brace.square.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts meta.type.tuple.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts meta.type.tuple.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts meta.type.tuple.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts meta.type.tuple.ts meta.brace.square.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts punctuation.separator.comma.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.begin.ts +> some SQL here + ^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts string.template.ts +> `) + ^^^^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts string.template.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts string.template.ts punctuation.definition.string.template.end.ts + ^ + source.ts meta.function.ts meta.block.ts meta.var.expr.ts meta.brace.round.ts +> return database.execute(query) + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts variable.other.object.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts punctuation.accessor.ts + ^^^^^^^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^^^^^ + source.ts meta.function.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue578.baseline.txt b/tests/baselines/Issue578.baseline.txt new file mode 100644 index 00000000..9966b040 --- /dev/null +++ b/tests/baselines/Issue578.baseline.txt @@ -0,0 +1,90 @@ +original file +----------------------------------- +if (targetAttribute) { + if (!(targetAttribute instanceof Attribute)) { + targetAttribute = new Attribute(targetAttribute); + } +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>if (targetAttribute) { + ^^ + source.ts keyword.control.conditional.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +> if (!(targetAttribute instanceof Attribute)) { + ^^^^ + source.ts meta.block.ts + ^^ + source.ts meta.block.ts keyword.control.conditional.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts keyword.operator.logical.ts + ^ + source.ts meta.block.ts meta.brace.round.ts + ^^^^^^^^^^^^^^^ + source.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts + ^^^^^^^^^^ + source.ts meta.block.ts keyword.operator.expression.instanceof.ts + ^ + source.ts meta.block.ts + ^^^^^^^^^ + source.ts meta.block.ts entity.name.type.ts + ^ + source.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +> targetAttribute = new Attribute(targetAttribute); + ^^^^^^^^ + source.ts meta.block.ts meta.block.ts + ^^^^^^^^^^^^^^^ + source.ts meta.block.ts meta.block.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts keyword.operator.assignment.ts + ^ + source.ts meta.block.ts meta.block.ts + ^^^ + source.ts meta.block.ts meta.block.ts new.expr.ts keyword.operator.new.ts + ^ + source.ts meta.block.ts meta.block.ts new.expr.ts + ^^^^^^^^^ + source.ts meta.block.ts meta.block.ts new.expr.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^^^^^^^^^^^^^^^ + source.ts meta.block.ts meta.block.ts new.expr.ts variable.other.readwrite.ts + ^ + source.ts meta.block.ts meta.block.ts new.expr.ts meta.brace.round.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.terminator.statement.ts +> } + ^^^^ + source.ts meta.block.ts meta.block.ts + ^ + source.ts meta.block.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue579.baseline.txt b/tests/baselines/Issue579.baseline.txt new file mode 100644 index 00000000..b4e41450 --- /dev/null +++ b/tests/baselines/Issue579.baseline.txt @@ -0,0 +1,122 @@ +original file +----------------------------------- +function f(): (x: number) => any { + return true ? x => f() : x => 0; +} +const x = 0; // no highlight in rest of file +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>function f(): (x: number) => any { + ^^^^^^^^ + source.ts meta.function.ts storage.type.function.ts + ^ + source.ts meta.function.ts + ^ + source.ts meta.function.ts meta.definition.function.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.ts meta.parameters.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts + ^^^^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.ts meta.parameters.ts meta.type.annotation.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.function.ts meta.return.type.ts + ^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^^^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.function.ts meta.return.type.ts meta.type.function.return.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +> return true ? x => f() : x => 0; + ^^^^ + source.ts meta.function.ts meta.block.ts + ^^^^^^ + source.ts meta.function.ts meta.block.ts keyword.control.flow.ts + ^ + source.ts meta.function.ts meta.block.ts + ^^^^ + source.ts meta.function.ts meta.block.ts constant.language.boolean.true.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.arrow.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts meta.arrow.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.arrow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts meta.brace.round.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts keyword.operator.ternary.ts + ^ + source.ts meta.function.ts meta.block.ts + ^ + source.ts meta.function.ts meta.block.ts meta.arrow.ts variable.parameter.ts + ^ + source.ts meta.function.ts meta.block.ts meta.arrow.ts + ^^ + source.ts meta.function.ts meta.block.ts meta.arrow.ts storage.type.function.arrow.ts + ^ + source.ts meta.function.ts meta.block.ts meta.arrow.ts + ^ + source.ts meta.function.ts meta.block.ts constant.numeric.decimal.ts + ^ + source.ts meta.function.ts meta.block.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.function.ts meta.block.ts punctuation.definition.block.ts +>const x = 0; // no highlight in rest of file + ^^^^^ + source.ts meta.var.expr.ts storage.type.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts meta.definition.variable.ts variable.other.constant.ts + ^ + source.ts meta.var.expr.ts meta.var-single-variable.expr.ts + ^ + source.ts meta.var.expr.ts keyword.operator.assignment.ts + ^ + source.ts meta.var.expr.ts + ^ + source.ts meta.var.expr.ts constant.numeric.decimal.ts + ^ + source.ts punctuation.terminator.statement.ts + ^ + source.ts + ^^ + source.ts comment.line.double-slash.ts punctuation.definition.comment.ts + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + source.ts comment.line.double-slash.ts \ No newline at end of file diff --git a/tests/baselines/Issue580.baseline.txt b/tests/baselines/Issue580.baseline.txt new file mode 100644 index 00000000..944bd868 --- /dev/null +++ b/tests/baselines/Issue580.baseline.txt @@ -0,0 +1,40 @@ +original file +----------------------------------- +(a[0] / 2) / (2) +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>(a[0] / 2) / (2) + ^ + source.ts meta.brace.round.ts + ^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts meta.array.literal.ts constant.numeric.decimal.ts + ^ + source.ts meta.array.literal.ts meta.brace.square.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts constant.numeric.decimal.ts + ^ + source.ts meta.brace.round.ts \ No newline at end of file diff --git a/tests/baselines/Issue581.baseline.txt b/tests/baselines/Issue581.baseline.txt new file mode 100644 index 00000000..88b34481 --- /dev/null +++ b/tests/baselines/Issue581.baseline.txt @@ -0,0 +1,72 @@ +original file +----------------------------------- +interface Foo { + a: () => void; + b?: () => void; +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>interface Foo { + ^^^^^^^^^ + source.ts meta.interface.ts storage.type.interface.ts + ^ + source.ts meta.interface.ts + ^^^ + source.ts meta.interface.ts entity.name.type.interface.ts + ^ + source.ts meta.interface.ts + ^ + source.ts meta.interface.ts punctuation.definition.block.ts +> a: () => void; + ^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts entity.name.function.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.return.ts + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +> b?: () => void; + ^^ + source.ts meta.interface.ts meta.field.declaration.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.definition.property.ts entity.name.function.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts keyword.operator.optional.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts keyword.operator.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.begin.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.ts meta.parameters.ts punctuation.definition.parameters.end.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts + ^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.return.ts storage.type.function.arrow.ts + ^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.return.ts + ^^^^ + source.ts meta.interface.ts meta.field.declaration.ts meta.type.annotation.ts meta.type.function.return.ts support.type.primitive.ts + ^ + source.ts meta.interface.ts punctuation.terminator.statement.ts +>} + ^ + source.ts meta.interface.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue584.baseline.txt b/tests/baselines/Issue584.baseline.txt new file mode 100644 index 00000000..7eea3883 --- /dev/null +++ b/tests/baselines/Issue584.baseline.txt @@ -0,0 +1,110 @@ +original file +----------------------------------- +if (startDragXOffset < cornerDistanceThreshold > (shapeWidth - cornerDistanceThreshold)) { +} +if (startDragXOffset < cornerDistanceThreshold && startDragYOffset > (shapeWidth - cornerDistanceThreshold)) { +} +----------------------------------- + +Grammar: TypeScript.tmLanguage +----------------------------------- +>if (startDragXOffset < cornerDistanceThreshold > (shapeWidth - cornerDistanceThreshold)) { + ^^ + source.ts keyword.control.conditional.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^^^^^^^^^ + source.ts meta.function-call.ts entity.name.function.ts + ^ + source.ts + ^ + source.ts meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + ^ + source.ts meta.type.parameters.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts meta.type.parameters.ts entity.name.type.ts + ^ + source.ts meta.type.parameters.ts + ^ + source.ts meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts +>if (startDragXOffset < cornerDistanceThreshold && startDragYOffset > (shapeWidth - cornerDistanceThreshold)) { + ^^ + source.ts keyword.control.conditional.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.relational.ts + ^ + source.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^^ + source.ts keyword.operator.logical.ts + ^ + source.ts + ^^^^^^^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.relational.ts + ^ + source.ts + ^ + source.ts meta.brace.round.ts + ^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts + ^ + source.ts keyword.operator.arithmetic.ts + ^ + source.ts + ^^^^^^^^^^^^^^^^^^^^^^^ + source.ts variable.other.readwrite.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts meta.brace.round.ts + ^ + source.ts + ^ + source.ts meta.block.ts punctuation.definition.block.ts +>} + ^ + source.ts meta.block.ts punctuation.definition.block.ts \ No newline at end of file diff --git a/tests/baselines/Issue585.baseline.txt b/tests/baselines/Issue585.baseline.txt new file mode 100644 index 00000000..62ee3c25 --- /dev/null +++ b/tests/baselines/Issue585.baseline.txt @@ -0,0 +1,46 @@ +original file +----------------------------------- +// @onlyOwnGrammar - As this has jsx +const a = `, + directives: [CountClicks] +}) +export class AppComponent { + constructor() { console.clear(); } +} \ No newline at end of file diff --git a/tests/cases/Issue146.ts b/tests/cases/Issue146.ts new file mode 100644 index 00000000..e0ba6757 --- /dev/null +++ b/tests/cases/Issue146.ts @@ -0,0 +1,8 @@ +function foo() { + return 'bar'; +} + +function* foo() { + yield 'bar'; + yield* ['bar']; +} \ No newline at end of file diff --git a/tests/cases/Issue148.ts b/tests/cases/Issue148.ts new file mode 100644 index 00000000..9498f9e2 --- /dev/null +++ b/tests/cases/Issue148.ts @@ -0,0 +1,8 @@ +class Test { + constructor( + @inject private test: string, + @inject("test") private test2: string, + @inject("test") test3: string, + public test4: string + ) { } +} \ No newline at end of file diff --git a/tests/cases/Issue149.ts b/tests/cases/Issue149.ts index 2c3a95f2..ab9973af 100644 --- a/tests/cases/Issue149.ts +++ b/tests/cases/Issue149.ts @@ -1,13 +1,13 @@ -^^export function ^^fn(s: ^^string): ^^new() => ^^View -^^export function ^^fn(s: string) -^^export function ^^fn(n: number) -^^export function ^^fn(s: any) { - ^^return ""; +export function fn(s: string): new() => View +export function fn(s: string) +export function fn(n: number) +export function fn(s: any) { + return ""; } -^^export function ^^fn(s: string): ^^new () => ^^View; -^^export function ^^fn(s: string); -^^export function ^^fn(n: number); -^^export function ^^fn(s: any) { - ^^return ""; +export function fn(s: string): new () => View; +export function fn(s: string); +export function fn(n: number); +export function fn(s: any) { + return ""; } \ No newline at end of file diff --git a/tests/cases/Issue152.ts b/tests/cases/Issue152.ts new file mode 100644 index 00000000..f9d58d19 --- /dev/null +++ b/tests/cases/Issue152.ts @@ -0,0 +1,8 @@ +var node; +for(var i; i< 45;i++) { + node = 234; + + node.a = 122; + node.b += 122; + node.b += '1'+1+'2'; +} \ No newline at end of file diff --git a/tests/cases/Issue153.ts b/tests/cases/Issue153.ts new file mode 100644 index 00000000..817c283b --- /dev/null +++ b/tests/cases/Issue153.ts @@ -0,0 +1,57 @@ +import {Vector3, Vector} from 'vectors'; + +/** + * A simple 3x3 matrix structure. + * + * @export + * @class Matrix3x3 + */ +class Matrix { + public M11 : number; + public M12 : number; + public M13 : number; + public M21 : number; + public M22 : number; + public M23 : number; + public M31 : number; + public M32 : number; + public M33 : number; + + + /** + * Gets a column as a new vector. + * + * @param {number} index The index of the column (0 .. 2). + * @returns {Vector3} A vector representing the column. + */ + public getColumn_Breaks(index : number) : Vector3 { + if (index == 0) { + return new Vector3(this.M11, this.M21, this.M31); + } else if (index == 1) { + return new Vector3(this.M12, this.M22, this.M32); + } else if (index == 2) { + return new Vector3(this.M13, this.M23, this.M33); + } else { + throw new RangeError('Invalid matrix 3x3 column index: ' + index); + } + } + + /** + * Gets a column as a new vector. + * + * @param {number} index The index of the column (0 .. 2). + * @returns {Vector3} A vector representing the column. + */ + public getColumn_Works(index : number) : Vector { + if (index == 0) { + return new Vector(this.M11, this.M21, this.M31); + } else if (index == 1) { + return new Vector(this.M12, this.M22, this.M32); + } else if (index == 2) { + return new Vector(this.M13, this.M23, this.M33); + } else { + throw new RangeError('Invalid matrix 3x3 column index: ' + index); + } + } + +} \ No newline at end of file diff --git a/tests/cases/Issue154.ts b/tests/cases/Issue154.ts new file mode 100644 index 00000000..dbac3dd2 --- /dev/null +++ b/tests/cases/Issue154.ts @@ -0,0 +1,11 @@ +class TestCase { + ['foo']() { + this.registerComponent('foo-bar'); + } +} + +class TestCase2 { + foo() { + this.registerComponent('foo-bar'); + } +} \ No newline at end of file diff --git a/tests/cases/Issue155.ts b/tests/cases/Issue155.ts new file mode 100644 index 00000000..505daa99 --- /dev/null +++ b/tests/cases/Issue155.ts @@ -0,0 +1,14 @@ +matchQuery.find().then(function (results) { + for (i=0;i([ 'foo', 'bar' ]); +items.delete('foo'); \ No newline at end of file diff --git a/tests/cases/Issue158.ts b/tests/cases/Issue158.ts new file mode 100644 index 00000000..ff7a9815 --- /dev/null +++ b/tests/cases/Issue158.ts @@ -0,0 +1,13 @@ +class Test +{ + public constructor() + { + for (let it=0; it<10; it++) + { + } + } + + private doSomething() + { + } +} \ No newline at end of file diff --git a/tests/cases/Issue161.tsx b/tests/cases/Issue161.tsx new file mode 100644 index 00000000..3806f52e --- /dev/null +++ b/tests/cases/Issue161.tsx @@ -0,0 +1,7 @@ +// @onlyOwnGrammar - As this has jsx +let root: React.ReactElement<{}>; +let page: PageName; +if (isViaPage) { + root = ; + page = 'via'; +} \ No newline at end of file diff --git a/tests/cases/Issue163.ts b/tests/cases/Issue163.ts new file mode 100644 index 00000000..470936a7 --- /dev/null +++ b/tests/cases/Issue163.ts @@ -0,0 +1,5 @@ +const o = { + async f() { + + } +}; \ No newline at end of file diff --git a/tests/cases/Issue166.ts b/tests/cases/Issue166.ts new file mode 100644 index 00000000..65089bb5 --- /dev/null +++ b/tests/cases/Issue166.ts @@ -0,0 +1,7 @@ +type x = string | "aaa" | "bbb" | "ccc" | number; +type x1 = string | + "aaa" | + "bbb" | "ccc" | number; +type x2 = string | /*comment*/ "aaa" | "bbb" | "ccc" | number; /*comment*/ +type x3 = string | "aaa" | //comment + "bbb" | "ccc" | number; //comment \ No newline at end of file diff --git a/tests/cases/Issue171.ts b/tests/cases/Issue171.ts new file mode 100644 index 00000000..13990c5c --- /dev/null +++ b/tests/cases/Issue171.ts @@ -0,0 +1,24 @@ +class c { + constructor + ( + private parameters: { + stringContent: string; + minLength: number; + maxLength: number, + validationErrorMessage: string + }) { + + } + private x: number = Date.now() // TODO: momentjs? + private link_visits_counter: number = 0; +} + +function foo() { + new c + ({ + stringContent: "something", + minLength: 1, + maxLength: 5, + validationErrorMessage: "something else" + }); +} \ No newline at end of file diff --git a/tests/cases/Issue172.ts b/tests/cases/Issue172.ts new file mode 100644 index 00000000..3189d48a --- /dev/null +++ b/tests/cases/Issue172.ts @@ -0,0 +1,2 @@ +let f = async (x) => {}; +let f2 = async function(x) {}; \ No newline at end of file diff --git a/tests/cases/Issue175.ts b/tests/cases/Issue175.ts new file mode 100644 index 00000000..cfd52af9 --- /dev/null +++ b/tests/cases/Issue175.ts @@ -0,0 +1,2 @@ +var $ = ''; +var $foo = ''; diff --git a/tests/cases/Issue177.ts b/tests/cases/Issue177.ts new file mode 100644 index 00000000..c9c9374b --- /dev/null +++ b/tests/cases/Issue177.ts @@ -0,0 +1,2 @@ +() => (/s/); +() => /s/; \ No newline at end of file diff --git a/tests/cases/Issue178.ts b/tests/cases/Issue178.ts new file mode 100644 index 00000000..17a07064 --- /dev/null +++ b/tests/cases/Issue178.ts @@ -0,0 +1,5 @@ +const a: { [key: string]: () => string } = null; +const b: { [key: string]: [string, () => string] } = null; +const c = "foobar"; +const d = 5; +const e: any = null; \ No newline at end of file diff --git a/tests/cases/Issue180.ts b/tests/cases/Issue180.ts new file mode 100644 index 00000000..2346bcc1 --- /dev/null +++ b/tests/cases/Issue180.ts @@ -0,0 +1,18 @@ +if (typeof oSettings.aanFeatures.f != 'undefined') +{ + var n = oSettings.aanFeatures.f; + for ( i=0, iLen=n.length ; i + { + } + + public method1(): void + { + } + private method2 () : number + { + return 2; + } + method3 () : string + { + return "method3"; + } +} \ No newline at end of file diff --git a/tests/cases/Issue186.ts b/tests/cases/Issue186.ts new file mode 100644 index 00000000..81904f56 --- /dev/null +++ b/tests/cases/Issue186.ts @@ -0,0 +1,10 @@ +function myFunction(param1, param2, number, string, boolean) { + let y = (number) => { + console.log(param1); + } + console.log(param1); + console.log(param1 + number); + console.log(string); + console.log(boolean); + let x = param1 ? 2 : param2; +} \ No newline at end of file diff --git a/tests/cases/Issue187.ts b/tests/cases/Issue187.ts new file mode 100644 index 00000000..d5a78375 --- /dev/null +++ b/tests/cases/Issue187.ts @@ -0,0 +1,5 @@ +const trim = module.exports = str => trim.trailing(trim.leading(str)); + +const trim = module.exports = function(str) { + return trim.trailing(trim.leading(str)); +} \ No newline at end of file diff --git a/tests/cases/Issue191.ts b/tests/cases/Issue191.ts index 1f92dd0b..c32d2214 100644 --- a/tests/cases/Issue191.ts +++ b/tests/cases/Issue191.ts @@ -1,19 +1,19 @@ class Thing { - ^^constructor(^^public ^^content: ^^string){ - var ^^prop = Q.defer<^^boolean>(^^); - ^^this.store = new ^^Data(); - ^^gaze(path.join(this.content, "^^**/*.json"^^), (err, watch) => { - ^^process.stuout.write(`^^Watching for changes in:`^^); + constructor(public content: string){ + var prop = Q.defer(); + this.store = new Data(); + gaze(path.join(this.content, "**/*.json"), (err, watch) => { + process.stuout.write(`Watching for changes in:`); }) }; } -class Thing<^^T, ^^U> { - ^^constructor(^^public ^^content: ^^string){ - var ^^prop = Q.defer<^^boolean>(^^); - ^^this.store = new ^^Data(); - ^^gaze(path.join(this.content, "^^**/*.json"^^), (err, watch) => { - ^^process.stuout.write(`^^Watching for changes in:`^^); +class Thing { + constructor(public content: string){ + var prop = Q.defer(); + this.store = new Data(); + gaze(path.join(this.content, "**/*.json"), (err, watch) => { + process.stuout.write(`Watching for changes in:`); }) }; } diff --git a/tests/cases/Issue193.ts b/tests/cases/Issue193.ts new file mode 100644 index 00000000..c3235c6a --- /dev/null +++ b/tests/cases/Issue193.ts @@ -0,0 +1,10 @@ +function Main_Функция(s: string) +{ +} + +function Функция_Main(s: string) +{ +} + +let item = "value1"; +let элемент = "value2"; \ No newline at end of file diff --git a/tests/cases/Issue197.ts b/tests/cases/Issue197.ts new file mode 100644 index 00000000..c2fa3238 --- /dev/null +++ b/tests/cases/Issue197.ts @@ -0,0 +1,14 @@ + export class sampleClass { + public equipmentTypeList: string[] = ["FAX", "OFFICE PHONE"]; + public pbxEquipmentType = "FAX"; + public spliceRightStripName = "TE"; + public cablePairStatusValues: any[] = + [ + { statusText: "Assigned" }, + { statusText: "Faulty" }, + { statusText: "Not in Use" }, + ]; + public cablePairStatusValueForAssigned = "Assigned"; + public cablePairStatusValueForFaulty = "Faulty"; + public phoneCircuitType = "Phone"; + } \ No newline at end of file diff --git a/tests/cases/Issue198.ts b/tests/cases/Issue198.ts new file mode 100644 index 00000000..99ccd580 --- /dev/null +++ b/tests/cases/Issue198.ts @@ -0,0 +1,6 @@ +let a = 0, b = 0, c = 0; +let value = a / b + / c; +let value2 = a / b + / c * a + b / a / b / c; +let value2 = a / b / c * a + b / a / b / c; \ No newline at end of file diff --git a/tests/cases/Issue200.ts b/tests/cases/Issue200.ts index 015f1381..630e1978 100644 --- a/tests/cases/Issue200.ts +++ b/tests/cases/Issue200.ts @@ -1,6 +1,6 @@ -^^ -^^declare ^^module ^^'goog:goog.i18n.NumberFormatSymbols_en_TT' { - ^^import ^^alias = ^^lool.clutz.goog.i18n.NumberFormatSymbols_en_TT; - ^^export ^^default ^^alias; -^^}^^ \ No newline at end of file + +declare module 'goog:goog.i18n.NumberFormatSymbols_en_TT' { + import alias = lool.clutz.goog.i18n.NumberFormatSymbols_en_TT; + export default alias; +} \ No newline at end of file diff --git a/tests/cases/Issue202.tsx b/tests/cases/Issue202.tsx new file mode 100644 index 00000000..6ac709df --- /dev/null +++ b/tests/cases/Issue202.tsx @@ -0,0 +1,10 @@ +interface Test { + test: T; +} + +interface Props { + prop: Test; +} + +class Whatever { +} \ No newline at end of file diff --git a/tests/cases/Issue203.ts b/tests/cases/Issue203.ts new file mode 100644 index 00000000..fb1324f4 --- /dev/null +++ b/tests/cases/Issue203.ts @@ -0,0 +1,6 @@ +var [] = 'fafa'.replace('blah'); +console.log('hello'); + +var [] = 'fafa'.replace(''); +console.log('hello'); +while { while() {} } \ No newline at end of file diff --git a/tests/cases/Issue206.ts b/tests/cases/Issue206.ts new file mode 100644 index 00000000..9a60ad28 --- /dev/null +++ b/tests/cases/Issue206.ts @@ -0,0 +1,42 @@ +interface A {} +interface B {} +interface C {} + +type D = A | B | C +type D1 = A + | B + | C +type D3 = + A + | B + | C +type D2 + = A + | B + | C + +type E = 'e1' | 'e2' | 'e3' +type E1 = 'e1' + | 'e2' + | 'e3' +type E2 = + 'e1' + | 'e2' + | 'e3' +type E3 + = 'e1' + | 'e2' + | 'e3' + +type F = A & B & C +type F1 = A + & B + & C +type F2 = + A + & B + & C +type F3 + = A + & B + & C \ No newline at end of file diff --git a/tests/cases/Issue208.ts b/tests/cases/Issue208.ts index aacd9d47..e05b8138 100644 --- a/tests/cases/Issue208.ts +++ b/tests/cases/Issue208.ts @@ -1,10 +1,10 @@ -var someVar = ^^new ^^Thing<^^number, ^^string>('^^data'^^); -var someVar = ^^makeThing<^^number, ^^string>('^^data'^^); +var someVar = new Thing('data'); +var someVar = makeThing('data'); class MyClass { - static ^^someProp = new ^^Thing<^^number, ^^string>('data'); - static ^^someProp = ^^makeThing<^^number, ^^string>('data'); + static someProp = new Thing('data'); + static someProp = makeThing('data'); - someProp = new ^^Thing<^^number, ^^string>('data'); - someProp = ^^makeThing<^^number, ^^string>('data'); + someProp = new Thing('data'); + someProp = makeThing('data'); } \ No newline at end of file diff --git a/tests/cases/Issue212.ts b/tests/cases/Issue212.ts new file mode 100644 index 00000000..daeae5d5 --- /dev/null +++ b/tests/cases/Issue212.ts @@ -0,0 +1,9 @@ +let from = neki; +from = a; // is a variable and should be in white color like other variables + +exports.myVar = async (ctx, next) => {} // this is all in white but exports and async should be e.g. in red or blue + +t.me = 1; +t.is = 2; // `is` is in blue but should be the same color as the above (1) +t.in = 3; // `in` is in blue but should be the same color as the above (1) +t.of = 4; // `of` is in blue but should be the same color as the above (1) \ No newline at end of file diff --git a/tests/cases/Issue215.ts b/tests/cases/Issue215.ts new file mode 100644 index 00000000..81d34e04 --- /dev/null +++ b/tests/cases/Issue215.ts @@ -0,0 +1,9 @@ +function test() { + for (var i=0 ; i + { + // From this point on the syntax highlighting will be confused as to where it is. + var myVar = 5; + console.log("Hello there!"); + } +} \ No newline at end of file diff --git a/tests/cases/Issue217.ts b/tests/cases/Issue217.ts new file mode 100644 index 00000000..d2c5d78b --- /dev/null +++ b/tests/cases/Issue217.ts @@ -0,0 +1,9 @@ +export class StatusSelector { + @Output() select = new EventEmitter() + statuses = ["started", "completed"] +} + +export class StatusSelector2 { + @Output() select = new EventEmitter(); + statuses = ["started", "completed"] +} \ No newline at end of file diff --git a/tests/cases/Issue218.ts b/tests/cases/Issue218.ts new file mode 100644 index 00000000..4c04cbfc --- /dev/null +++ b/tests/cases/Issue218.ts @@ -0,0 +1,6 @@ +class A { + foo(a, b) { + } + [foo](a, b) { + } +} \ No newline at end of file diff --git a/tests/cases/Issue219.ts b/tests/cases/Issue219.ts new file mode 100644 index 00000000..7b120c3d --- /dev/null +++ b/tests/cases/Issue219.ts @@ -0,0 +1,6 @@ +const { + map, + coordinate +} = this.props +if (!map) return; +var marker; \ No newline at end of file diff --git a/tests/cases/Issue22.ts b/tests/cases/Issue22.ts new file mode 100644 index 00000000..1ec88268 --- /dev/null +++ b/tests/cases/Issue22.ts @@ -0,0 +1,2 @@ +app.get('/test/', (req, res) => { +}); \ No newline at end of file diff --git a/tests/cases/Issue221.ts b/tests/cases/Issue221.ts new file mode 100644 index 00000000..cbc49d8d --- /dev/null +++ b/tests/cases/Issue221.ts @@ -0,0 +1,10 @@ +class syntaxHighlightBug { + + variable = + {"example":1}; + + public wronglyHighlitedCode() { + var a = 1; + return; + } +} \ No newline at end of file diff --git a/tests/cases/Issue223.ts b/tests/cases/Issue223.ts new file mode 100644 index 00000000..7d72ec63 --- /dev/null +++ b/tests/cases/Issue223.ts @@ -0,0 +1,6 @@ +for (i = 0; i { } \ No newline at end of file diff --git a/tests/cases/Issue230.ts b/tests/cases/Issue230.ts new file mode 100644 index 00000000..3e38c7f8 --- /dev/null +++ b/tests/cases/Issue230.ts @@ -0,0 +1,6 @@ +// Note: `new Date` without parenthesis (`new Date()`) +ctrl.filter("dateFilter", () => (input: mycivis.IAll[], date: Date = new Date) => input.filter((value, index, array) => { + let date2 = value.date || (value.day) ? moment(`${value.day} ${value.time}`, "YYYY-MM-DD HH:mm").toDate() : next_wday(value.wday); + + return moment(date).format("DD/MMM/YYYY") === moment(date2).format("DD/MMM/YYYY"); +})); \ No newline at end of file diff --git a/tests/cases/Issue232.ts b/tests/cases/Issue232.ts new file mode 100644 index 00000000..29e19b2e --- /dev/null +++ b/tests/cases/Issue232.ts @@ -0,0 +1,3 @@ +for( let [k, component] of this.components){ + let bounds = component.view.getBounds(); /// <= not highlighted, nor anything after this +} \ No newline at end of file diff --git a/tests/cases/Issue235.ts b/tests/cases/Issue235.ts new file mode 100644 index 00000000..94d1b5e0 --- /dev/null +++ b/tests/cases/Issue235.ts @@ -0,0 +1,6 @@ +class A { + @Route.GET('/*') + get(q: Request, s: Response): void { + s.sendFile(); + } +} \ No newline at end of file diff --git a/tests/cases/Issue236.ts b/tests/cases/Issue236.ts new file mode 100644 index 00000000..ecd06aa6 --- /dev/null +++ b/tests/cases/Issue236.ts @@ -0,0 +1,13 @@ +class Test { + public before() { + // ... + } + + public [Symbol.iterator]() { + // ... + } + + public after() { + // ... + } +} \ No newline at end of file diff --git a/tests/cases/Issue237.ts b/tests/cases/Issue237.ts new file mode 100644 index 00000000..ef15e2b1 --- /dev/null +++ b/tests/cases/Issue237.ts @@ -0,0 +1,2 @@ +export type Test = string // wrong comment color + // should be this \ No newline at end of file diff --git a/tests/cases/Issue239.tsx b/tests/cases/Issue239.tsx new file mode 100644 index 00000000..625b2749 --- /dev/null +++ b/tests/cases/Issue239.tsx @@ -0,0 +1,2 @@ +// @onlyOwnGrammar - As this has jsx + const test = (true) ?

Broken Color

:

Also Broken Color

\ No newline at end of file diff --git a/tests/cases/Issue241.ts b/tests/cases/Issue241.ts new file mode 100644 index 00000000..297e1bf5 --- /dev/null +++ b/tests/cases/Issue241.ts @@ -0,0 +1,15 @@ +function f(): () => number { + const x = 0; +} +function foo(): [number, () => number] { + const x = 0; +} +function f(): () => number { + const x = 0; +} +function f2(): () => {x: number }{ + const x = 0; +} +function foo2(): [number, () => { x: number }] { + const x = 0; +} \ No newline at end of file diff --git a/tests/cases/Issue243.ts b/tests/cases/Issue243.ts new file mode 100644 index 00000000..0546acc1 --- /dev/null +++ b/tests/cases/Issue243.ts @@ -0,0 +1,108 @@ +'use strict'; + + var pieces = []; + var numeration = []; + + for (var i in pieces) { + switch (true) { + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + case /^\"?Accession\"?/.test(pieces[i]): + numeration[0] = i; + break; + } + } diff --git a/tests/cases/Issue244.ts b/tests/cases/Issue244.ts new file mode 100644 index 00000000..9d12ce54 --- /dev/null +++ b/tests/cases/Issue244.ts @@ -0,0 +1,7 @@ +a.withLatestFrom(axis === 'x' ? initialX : initialY) + .map(x => undefined) + .switch() + .publish().refCount(); + +const targetX = targetSideObs('x'); +const targetY = targetSideObs('y'); \ No newline at end of file diff --git a/tests/cases/Issue247.tsx b/tests/cases/Issue247.tsx new file mode 100644 index 00000000..9585c29d --- /dev/null +++ b/tests/cases/Issue247.tsx @@ -0,0 +1,3 @@ +@dec<{}>() +class Test { +} diff --git a/tests/cases/Issue248.ts b/tests/cases/Issue248.ts new file mode 100644 index 00000000..c053a700 --- /dev/null +++ b/tests/cases/Issue248.ts @@ -0,0 +1,36 @@ +class C1 { + m1 = 1; + static s1() { + return [() => (new this).m1]; + } +} +class C2 { + m1 = 1; + static s1() { + return [() => (new this).m1]; + } +} +class C3 { + m1 = 1; + static s1() { + return [() => (new this).m1]; + } +} +class C4 { + m1 = 1; + static s1() { + return [() => (new this).m1]; + } +} +class C5 { + m1 = 1; + static s1() { + return [() => (new this).m1]; + } +} +class C6 { + m1 = 1; + static s1() { + return [() => (new this).m1]; + } +} \ No newline at end of file diff --git a/tests/cases/Issue249.ts b/tests/cases/Issue249.ts new file mode 100644 index 00000000..2c69051f --- /dev/null +++ b/tests/cases/Issue249.ts @@ -0,0 +1,7 @@ +const selectDictionary = (dictionaries: StoredDictionaries, lang:string) => { + +} + +function selectDictionary(dictionaries: StoredDictionaries, lang:string) { + +} \ No newline at end of file diff --git a/tests/cases/Issue250.ts b/tests/cases/Issue250.ts new file mode 100644 index 00000000..ccb102fc --- /dev/null +++ b/tests/cases/Issue250.ts @@ -0,0 +1,22 @@ +/** Meta-part that defins a Form */ +export class FormType extends Type { + + /** @internal Original FormType instance */ + static Original = function () { + let type = new FormType; + + // define embed field + type.defineField(DesignID.Embed, new BooleanAtom(false)); + + // define plan choice + type.defineField(DesignID.Plan, PlanChoice.Original); + + // define fields list + let fields = + type.defineField(DesignID.Fields, new Ordering(new FieldDesign)); + // embed field list + fields.embed = true; + + return type; + } (); +} \ No newline at end of file diff --git a/tests/cases/Issue251.ts b/tests/cases/Issue251.ts new file mode 100644 index 00000000..b597c54c --- /dev/null +++ b/tests/cases/Issue251.ts @@ -0,0 +1,6 @@ +for(var j=0; (j +
+
+ \ No newline at end of file diff --git a/tests/cases/Issue276.ts b/tests/cases/Issue276.ts new file mode 100644 index 00000000..2a621189 --- /dev/null +++ b/tests/cases/Issue276.ts @@ -0,0 +1,8 @@ +/** + * @param {string} value + * @param {string[]} arrayValue + * @param {string} [optionalValue] + */ +function test(value: string, arrayValue: string[], optionalValue?: string) { + +} \ No newline at end of file diff --git a/tests/cases/Issue28.ts b/tests/cases/Issue28.ts index 6d439f84..5d6eac45 100644 --- a/tests/cases/Issue28.ts +++ b/tests/cases/Issue28.ts @@ -1,10 +1,9 @@ /* Testing octals */ -var x = ^^123; -var y = ^^0x123; -var z = ^^0b10101; -var z = ^^0B00000; -var j = ^^0o474774; -var w = ^^0O767; -^^ \ No newline at end of file +var x = 123; +var y = 0x123; +var z = 0b10101; +var z = 0B00000; +var j = 0o474774; +var w = 0O767; diff --git a/tests/cases/Issue280.tsx b/tests/cases/Issue280.tsx new file mode 100644 index 00000000..7ced43e0 --- /dev/null +++ b/tests/cases/Issue280.tsx @@ -0,0 +1,26 @@ +// @onlyOwnGrammar - As this has jsx +class c { + private renderForecastsTable() { + let forecasts = this.props.forecasts.map(forecast => { + return forecast.dateFormatted + + forecast.temperatureC + + forecast.temperatureF + + forecast.summar; + }); + return + + + + { + this.props.forecasts.map(forecast => { + return forecast.dateFormatted + + forecast.temperatureC + + forecast.temperatureF + + forecast.summar; + }) + } + +
; + } + +} \ No newline at end of file diff --git a/tests/cases/Issue283.tsx b/tests/cases/Issue283.tsx new file mode 100644 index 00000000..b70d53cf --- /dev/null +++ b/tests/cases/Issue283.tsx @@ -0,0 +1,25 @@ +// @onlyOwnGrammar - As this has jsx +import * as React from 'react'; + +export default class Home extends React.Component { + public render() { + return
+

Hello, world!

+

Welcome to your new single-page application, built with:

+ +

To help you get started, we've also set up:

+
    +
  • Client-side navigation. For example, click Counter then Back to return here.
    • +
  • Webpack dev middleware. In development mode, there's no need to run the webpack build tool. Your client-side resources are dynamically built on demand. Updates are available as soon as you modify any file.
    • +
  • Hot module replacement. In development mode, you don't even need to reload the page after making most changes. Within seconds of saving changes to files, rebuilt React components will be injected directly into your running application, preserving its live state.
    • +
  • Efficient production builds. In production mode, development-time features are disabled, and the webpack build tool produces minified static CSS and JavaScript files.
    • +
  • Server-side prerendering. To optimize startup time, your React application is first rendered on the server. The initial HTML and state is then transferred to the browser, where client-side code picks up where the server left off.
    • +
+
; + } +} \ No newline at end of file diff --git a/tests/cases/Issue285.ts b/tests/cases/Issue285.ts new file mode 100644 index 00000000..cba79a53 --- /dev/null +++ b/tests/cases/Issue285.ts @@ -0,0 +1,5 @@ +let model = { + links: { + new: "sample" + }, + }; diff --git a/tests/cases/Issue288.ts b/tests/cases/Issue288.ts index 43d64941..715d7ff1 100644 --- a/tests/cases/Issue288.ts +++ b/tests/cases/Issue288.ts @@ -1,23 +1,23 @@ // Issue 288: "function" in "functionName" gets highlighted. // Fixed in pull request #289. -function ^^Name(){ +function Name(){ } -var AnotherName = function^^(){ +var AnotherName = function(){ } -export function ^^eName(){ +export function eName(){ } -export var eAnotherName = function^^(){ +export var eAnotherName = function(){ } -var function^^Name=1; -function^^Name=1; +var functionName=1; +functionName=1; -export var function^^Name2=1; +export var functionName2=1; -var export^^Name="hello"; -export^^Name2="hello"; +var exportName="hello"; +exportName2="hello"; -var return^^Name=1; -return^^Name+=1; +var returnName=1; +returnName+=1; diff --git a/tests/cases/Issue292.ts b/tests/cases/Issue292.ts new file mode 100644 index 00000000..3bd1570e --- /dev/null +++ b/tests/cases/Issue292.ts @@ -0,0 +1,10 @@ + const shellOptions: IOptions = { + filesToOpen, + filesToCreate, + filesToDiff + }; + const a = { + filesToOpen: filesToOpen, + filesToCreate: filesToCreate, + filesToDiff: filesToDiff + } \ No newline at end of file diff --git a/tests/cases/Issue294.ts b/tests/cases/Issue294.ts new file mode 100644 index 00000000..58b5fdf3 --- /dev/null +++ b/tests/cases/Issue294.ts @@ -0,0 +1,6 @@ +switch (0) { + case 0: { + const zero = 0; + return zero; + } +} \ No newline at end of file diff --git a/tests/cases/Issue3.ts b/tests/cases/Issue3.ts new file mode 100644 index 00000000..47e0eba2 --- /dev/null +++ b/tests/cases/Issue3.ts @@ -0,0 +1 @@ +let regex = /**/ /foo/; \ No newline at end of file diff --git a/tests/cases/Issue304.ts b/tests/cases/Issue304.ts new file mode 100644 index 00000000..df79a352 --- /dev/null +++ b/tests/cases/Issue304.ts @@ -0,0 +1,9 @@ +export const EditorPanel = connect( + (state: Immutable): Object => ( { + edditorState: (state.editors[state.activeTab]), + macroSettingsOpen: state.macroSettingsOpen, + }), + (dispatch: Dispatch): Object => ({ + onchange(next: EditorSDtate): void { dispatch(actions) } + }) +) \ No newline at end of file diff --git a/tests/cases/Issue305.ts b/tests/cases/Issue305.ts new file mode 100644 index 00000000..160711db --- /dev/null +++ b/tests/cases/Issue305.ts @@ -0,0 +1,4 @@ +abstract class Base { + protected abstract topic: string + constructor(protected wire: Transport, protected token?: string, readonly bar?: boolean) { } +} \ No newline at end of file diff --git a/tests/cases/Issue307.ts b/tests/cases/Issue307.ts new file mode 100644 index 00000000..69f93dce --- /dev/null +++ b/tests/cases/Issue307.ts @@ -0,0 +1,9 @@ +class Test { + method() { + const obj = { a: 'hello' }; + const { + a + } = obj; + const x = 'world'; + } +} \ No newline at end of file diff --git a/tests/cases/Issue314.ts b/tests/cases/Issue314.ts new file mode 100644 index 00000000..f0541091 --- /dev/null +++ b/tests/cases/Issue314.ts @@ -0,0 +1,2 @@ +let x = a ? b as X : c; +let y = 123; \ No newline at end of file diff --git a/tests/cases/Issue318.ts b/tests/cases/Issue318.ts new file mode 100644 index 00000000..5af2233d --- /dev/null +++ b/tests/cases/Issue318.ts @@ -0,0 +1,8 @@ + this.Then( + /^display prompt in branch "([^"]*)"$/, + async function (branchName) { + const expected = application.prompt(branchName); + const actual = await application.getOnceOut(); + expect(actual).to.be.equal(expected); + } + ); diff --git a/tests/cases/Issue32.ts b/tests/cases/Issue32.ts index 724c498d..6468411d 100644 --- a/tests/cases/Issue32.ts +++ b/tests/cases/Issue32.ts @@ -2,20 +2,20 @@ Testing Isuue 32: Adding constructor as a support.type keword */ -^^interface ^^NewInterface{ - ^^currentData: Data; - ^^setVal(d: Data) +interface NewInterface{ + currentData: Data; + setVal(d: Data) } -^^class NewClass implements NewInterface { - ^^currentData: Data; - ^^setVal(d: Data){ - ^^this.currentData = d; +class NewClass implements NewInterface { + currentData: Data; + setVal(d: Data){ + this.currentData = d; } - ^^constructor(^^m: ^^number, ^^n: ^^string){} + constructor(m: number, n: string){} } -^^ + /* Testing comments */ \ No newline at end of file diff --git a/tests/cases/Issue321.ts b/tests/cases/Issue321.ts new file mode 100644 index 00000000..5ce3c049 --- /dev/null +++ b/tests/cases/Issue321.ts @@ -0,0 +1,40 @@ +export abstract class ExpressionContainer implements debug.IExpressionContainer { + public getChildren(debugService: debug.IDebugService): TPromise { + if (!this.cacheChildren || !this.children) { + const session = debugService.activeSession; + // only variables with reference > 0 have children. + if (!session || this.reference <= 0) { + this.children = TPromise.as([]); + } else { + + // Check if object has named variables, fetch them independent from indexed variables #9670 + this.children = (!!this.namedVariables ? this.fetchVariables(session, undefined, undefined, 'named') : TPromise.as([])).then(childrenArray => { + // Use a dynamic chunk size based on the number of elements #9774 + let chunkSize = ExpressionContainer.BASE_CHUNK_SIZE; + while (this.indexedVariables > chunkSize * ExpressionContainer.BASE_CHUNK_SIZE) { + chunkSize *= ExpressionContainer.BASE_CHUNK_SIZE; + } + + if (this.indexedVariables > chunkSize) { + // There are a lot of children, create fake intermediate values that represent chunks #9537 + const numberOfChunks = Math.ceil(this.indexedVariables / chunkSize); + for (let i = 0; i < numberOfChunks; i++) { + const start = this.startOfVariables + i * chunkSize; + const count = Math.min(chunkSize, this.indexedVariables - i * chunkSize); + childrenArray.push(new Variable(this, this.reference, `[${start}..${start + count - 1}]`, '', null, count, null, true, start)); + } + + return childrenArray; + } + + const start = this.getChildrenInChunks ? this.startOfVariables : undefined; + const count = this.getChildrenInChunks ? this.indexedVariables : undefined; + return this.fetchVariables(session, start, count, 'indexed') + .then(variables => arrays.distinct(childrenArray.concat(variables), child => child.name)); + }); + } + } + + return this.children; + } +} \ No newline at end of file diff --git a/tests/cases/Issue322.ts b/tests/cases/Issue322.ts new file mode 100644 index 00000000..ddcf2e09 --- /dev/null +++ b/tests/cases/Issue322.ts @@ -0,0 +1,24 @@ +export enum TokenType { + StartCommentTag, + Comment, + EndCommentTag, + StartTagOpen, + StartTagClose, + StartTagSelfClose, + StartTag, + EndTagOpen, + EndTagClose, + EndTag, + DelimiterAssign, + AttributeName, + AttributeValue, + StartDoctypeTag, + Doctype, + EndDoctypeTag, + Content, + Whitespace, + Unknown, + Script, + Styles, + EOS +} \ No newline at end of file diff --git a/tests/cases/Issue326.ts b/tests/cases/Issue326.ts new file mode 100644 index 00000000..94cd66f9 --- /dev/null +++ b/tests/cases/Issue326.ts @@ -0,0 +1 @@ +class Bar extends getFoo("baz") {} \ No newline at end of file diff --git a/tests/cases/Issue334.ts b/tests/cases/Issue334.ts new file mode 100644 index 00000000..aad7f23a --- /dev/null +++ b/tests/cases/Issue334.ts @@ -0,0 +1,22 @@ +var Backbone= require("backbone"); +var SearchModel= require("./../search/models/SearchModel"); +var ResultsContainerModel= require("./ResultsContainerModel"); + +var _PROP_SEARCH_ = "SEARCH"; +var _PROP_RESULTS_CONTAINER_ = "SERCH_RESULTS"; + +var PageModel= Backbone.Model.extend({ + + defaults: function() { + var defaults= {}; + defaults[_PROP_SEARCH_]= new SearchModel(); + defaults[_PROP_RESULTS_CONTAINER_]= new ResultsContainerModel(); + return defaults; + }, + +}, { + propSearch: _PROP_SEARCH_, + propResultsContainer: _PROP_RESULTS_CONTAINER_ +}); + +module.exports= PageModel; \ No newline at end of file diff --git a/tests/cases/Issue335.ts b/tests/cases/Issue335.ts index 41cae164..7d50173e 100644 --- a/tests/cases/Issue335.ts +++ b/tests/cases/Issue335.ts @@ -1,51 +1,51 @@ class A1 { b() { let d; - d.^^default = 1; + d.default = 1; } - ^^private ^^static c() { + private static c() { } } class A2 { b() { let d; - d.^^case = 1 + d.case = 1 } - ^^private ^^static c() { + private static c() { } } class A3 { b() { let d - d.^^default = 1 - switch (d.^^default) { - ^^case 1: - ^^case 2: - ^^default: + d.default = 1 + switch (d.default) { + case 1: + case 2: + default: break; } } - ^^private ^^static c() { + private static c() { } } class A4 { b() { let d - d.^^case = 1 - switch (d.^^default) { - ^^case 1: - ^^case 2: - ^^default: + d.case = 1 + switch (d.default) { + case 1: + case 2: + default: break; } } - ^^private ^^static c() { + private static c() { } } \ No newline at end of file diff --git a/tests/cases/Issue337.ts b/tests/cases/Issue337.ts new file mode 100644 index 00000000..e96ee479 --- /dev/null +++ b/tests/cases/Issue337.ts @@ -0,0 +1 @@ +#!/usr/bin/env node -r babel-register \ No newline at end of file diff --git a/tests/cases/Issue338.ts b/tests/cases/Issue338.ts new file mode 100644 index 00000000..811a3169 --- /dev/null +++ b/tests/cases/Issue338.ts @@ -0,0 +1,3 @@ +let a = { + [['a', 'b', 'c'].join(' ')]: 'foo', +}; \ No newline at end of file diff --git a/tests/cases/Issue339.ts b/tests/cases/Issue339.ts new file mode 100644 index 00000000..e61da09c --- /dev/null +++ b/tests/cases/Issue339.ts @@ -0,0 +1,22 @@ +function f() { + + class implements BeingSpreading { + copy = copy; + fuse = fuse; + toInternalSpreading = toInternalSpreading; + toFiltersOnlySpreading = toFiltersOnlySpreading; + toResultsOnlySpreading = toResultsOnlySpreading; + toNormalSpreading = toNormalSpreading; + toNormalOrMaximizedSpreadingIfNotYet = ensureNormalOrMaximizedSpreading; + }; + + return new class implements BeingSpreading { + copy = copy; + fuse = fuse; + toInternalSpreading = toInternalSpreading; + toFiltersOnlySpreading = toFiltersOnlySpreading; + toResultsOnlySpreading = toResultsOnlySpreading; + toNormalSpreading = toNormalSpreading; + toNormalOrMaximizedSpreadingIfNotYet = ensureNormalOrMaximizedSpreading; + }; +} \ No newline at end of file diff --git a/tests/cases/Issue343.ts b/tests/cases/Issue343.ts new file mode 100644 index 00000000..eca5980e --- /dev/null +++ b/tests/cases/Issue343.ts @@ -0,0 +1 @@ +console.log(`${Math.round(responseTime / requests)} ns (${Math.round(requests / ( responseTime / 1e9))}/sec)`); \ No newline at end of file diff --git a/tests/cases/Issue344.tsx b/tests/cases/Issue344.tsx new file mode 100644 index 00000000..be24aa2d --- /dev/null +++ b/tests/cases/Issue344.tsx @@ -0,0 +1,6 @@ +let a = Array(); // Highlight ok here + +interface egGenericsInArray { + a: Array; +} +let s = "nothing should fail here..."; \ No newline at end of file diff --git a/tests/cases/Issue346.ts b/tests/cases/Issue346.ts new file mode 100644 index 00000000..dfa3752c --- /dev/null +++ b/tests/cases/Issue346.ts @@ -0,0 +1,29 @@ +function f() +{ + let t = 0 + let TAU440 = Math.PI*2 * 440 + + onmessage = function(e) + { + let b = new Float64Array(e.data.bufferSize) + let s = e.data.sampleRate + + for (let i = 0; i < b.length; i++) b[i] = Math.sin(TAU440 * t++/s * Math.sin(t++/s*.5)) + + postMessage(b) + } +} + +let a = new AudioContext() +let s = a.createScriptProcessor(0,1,1) +let b = new Float64Array(s.bufferSize) +let w = new Worker(URL.createObjectURL(new Blob(["("+f+"())"],{type:"application/javascript"}))) + +w.onmessage = e => b = e.data +s.connect(a.destination) + +s.onaudioprocess = function(e) +{ + w.postMessage({ bufferSize: s.bufferSize, sampleRate: a.sampleRate }) + e.outputBuffer.getChannelData(0).set(b) +} \ No newline at end of file diff --git a/tests/cases/Issue347.ts b/tests/cases/Issue347.ts new file mode 100644 index 00000000..79c39d0b --- /dev/null +++ b/tests/cases/Issue347.ts @@ -0,0 +1,12 @@ +const a = new Promise (resolve => { + const file = this.props.doc.file; + resolve({ + abc: Math.random() + }); + + class Foo extends React.Component { + render() { + } + } + +}); \ No newline at end of file diff --git a/tests/cases/Issue351.tsx b/tests/cases/Issue351.tsx new file mode 100644 index 00000000..dc4e9c20 --- /dev/null +++ b/tests/cases/Issue351.tsx @@ -0,0 +1,2 @@ +this._blockRenderMap = Map({}); +this._eventsMap = {}; \ No newline at end of file diff --git a/tests/cases/Issue356.ts b/tests/cases/Issue356.ts new file mode 100644 index 00000000..6e6c12e7 --- /dev/null +++ b/tests/cases/Issue356.ts @@ -0,0 +1,9 @@ +function formatBigNum(num) { + num = Number(num) + if (num < 10000) { + return num + } + return (num/10000).toString().replace(/(\.[\d]{1})\d+$/,"$1") + 'w ' +} +let hbAnimIndex = 0; +let hbAnimNode = null; \ No newline at end of file diff --git a/tests/cases/Issue357.tsx b/tests/cases/Issue357.tsx new file mode 100644 index 00000000..1aed9225 --- /dev/null +++ b/tests/cases/Issue357.tsx @@ -0,0 +1,23 @@ +// @onlyOwnGrammar - As this has jsx +const ProductPrice = ({inStock, price}) => { + const dashCode = 8211 + const dash = String.fromCharCode(dashCode) + return ( + + + {inStock + ? I18n.toCurrency(price) + :
+ {`${dash}`}{I18n.t('spree.out_of_stock')}{`${dash}`} +
} + + + ) +} \ No newline at end of file diff --git a/tests/cases/Issue359.ts b/tests/cases/Issue359.ts new file mode 100644 index 00000000..80df384a --- /dev/null +++ b/tests/cases/Issue359.ts @@ -0,0 +1,8 @@ +const test = (value: string) => { + const a = 123; + const b = { + [`${value}[]`]: a, + }; + const c = 123; + return b; +} \ No newline at end of file diff --git a/tests/cases/Issue36.ts b/tests/cases/Issue36.ts new file mode 100644 index 00000000..4823147b --- /dev/null +++ b/tests/cases/Issue36.ts @@ -0,0 +1,5 @@ +let x = { + hello() { + let hello = "world"; + } +}; \ No newline at end of file diff --git a/tests/cases/Issue361.ts b/tests/cases/Issue361.ts new file mode 100644 index 00000000..3880582c --- /dev/null +++ b/tests/cases/Issue361.ts @@ -0,0 +1,2 @@ +const constructor = someObject.prototype.constructor; + const objectLiteral = { constructor }; \ No newline at end of file diff --git a/tests/cases/Issue365.ts b/tests/cases/Issue365.ts new file mode 100644 index 00000000..9e429e62 --- /dev/null +++ b/tests/cases/Issue365.ts @@ -0,0 +1,3 @@ +class Renamer { + constructor (private readonly srcName: string, private readonly target: string, readonly copy: boolean = false) {} +} \ No newline at end of file diff --git a/tests/cases/Issue366.ts b/tests/cases/Issue366.ts new file mode 100644 index 00000000..6c4937de --- /dev/null +++ b/tests/cases/Issue366.ts @@ -0,0 +1,2 @@ +let foo = a ? b ? c : d : e; +let bar; \ No newline at end of file diff --git a/tests/cases/Issue368.ts b/tests/cases/Issue368.ts new file mode 100644 index 00000000..5007c69b --- /dev/null +++ b/tests/cases/Issue368.ts @@ -0,0 +1,5 @@ +let creditCard = 'cc'; +const CREDIT_CARD = 'CC'; + +console.log(`Payment Type: ${creditCard}`); +console.log(`Payment Type: ${CREDIT_CARD}`); \ No newline at end of file diff --git a/tests/cases/Issue37.ts b/tests/cases/Issue37.ts index 8ecedd7d..96d30b69 100644 --- a/tests/cases/Issue37.ts +++ b/tests/cases/Issue37.ts @@ -1,29 +1,29 @@ //Test For Scopes -^^import ^^* ^^as req ^^from "./Required" +import * as req from "./Required" import { Scale } from "./scale"; -^^if (object.^^instanceof(ClassNew)) { +if (object.instanceof(ClassNew)) { } -^^class ^^class1(){ - ^^static ^^functioname(){ +class class1(){ + static functioname(){ } } -^^export ^^class className(){ - ^^private ^^state = { } +export class className(){ + private state = { } } -^^void ^^newFunctionName(){ +void newFunctionName(){ - ^^var c = a ^^+ b; + var c = a + b; - ^^switch (someNum) { - ^^case 1: break; - ^^case 2: break; - ^^default: break; + switch (someNum) { + case 1: break; + case 2: break; + default: break; } } @@ -32,37 +32,37 @@ import { Scale } from "./scale"; * Verify comments */ -^^module M { - ^^export function myFun(x: number) { +module M { + export function myFun(x: number) { return x; } } -var m: ^^typeof M = M; +var m: typeof M = M; -var adder = ^^new Adder(3, 4); -^^delete (adder) +var adder = new Adder(3, 4); +delete (adder) var s = typeof {}git interface I {} var j: I = {} -^^module ^^Body { - ^^export ^^class ^^Cell { - ^^public ^^parent: ^^Cell; +module Body { + export class Cell { + public parent: Cell; - ^^constructor(^^parent: ^^Cell) { - ^^this.parent = ^^parent; - if (^^typeof ^^parent ^^=== ^^'object' || ^^parent ^^instanceof ^^Error) { - ^^ + constructor(parent: Cell) { + this.parent = parent; + if (typeof parent === 'object' || parent instanceof Error) { + } } } } /* -^^ + End of file */ \ No newline at end of file diff --git a/tests/cases/Issue375.ts b/tests/cases/Issue375.ts new file mode 100644 index 00000000..7059d5fe --- /dev/null +++ b/tests/cases/Issue375.ts @@ -0,0 +1,29 @@ +// @onlyOwnGrammar - As this has type assertion +class Foo { + constructor(public x: string) {} +} + +const foo1 = { x: '1' }; +const foo2 = { + x: '2' +}; +const foo3 = + { + x: '3' + }; + +let foos: Foo[] = [ + new Foo('4'), + { x: '5' }, + { + x: '6' + }, +]; + +let obj = Object.assign(new Foo('7'), { x: '8' }, + { x: '9' }, { x: '10' }, { + x: '11' + }, + { + x: '12' + }); \ No newline at end of file diff --git a/tests/cases/Issue376.ts b/tests/cases/Issue376.ts new file mode 100644 index 00000000..f7d7bd96 --- /dev/null +++ b/tests/cases/Issue376.ts @@ -0,0 +1,10 @@ + interface Itest { + a: 'a1' // a1 is good + | 'a2' // a2 is good + | 'a3' // a3 is good + b: { + a: 'a1' + | 'a2' // oh , the color is not good ! + | 'a3' // oh , the color is not good ! + } +} \ No newline at end of file diff --git a/tests/cases/Issue377.ts b/tests/cases/Issue377.ts new file mode 100644 index 00000000..64129f73 --- /dev/null +++ b/tests/cases/Issue377.ts @@ -0,0 +1 @@ +dt = ((dt[0] * 1e9 + dt[1]) / 1e6).toFixed(3).replace(/\.?0+$/, '') + 'ms'; diff --git a/tests/cases/Issue379.ts b/tests/cases/Issue379.ts new file mode 100644 index 00000000..1c3aabce --- /dev/null +++ b/tests/cases/Issue379.ts @@ -0,0 +1,7 @@ +interface A { + prop1: string + prop2: string + method1(): void + prop3: string + prop4: string +} \ No newline at end of file diff --git a/tests/cases/Issue380.ts b/tests/cases/Issue380.ts new file mode 100644 index 00000000..583de702 --- /dev/null +++ b/tests/cases/Issue380.ts @@ -0,0 +1,4 @@ +let namespace; +namespace = `${"a"}`; + +let x = 1 \ No newline at end of file diff --git a/tests/cases/Issue381.ts b/tests/cases/Issue381.ts new file mode 100644 index 00000000..0cadc3e1 --- /dev/null +++ b/tests/cases/Issue381.ts @@ -0,0 +1,11 @@ +class Foo{ + constructor(){ + + } + test(){ + return `/game.php?village=${source}&screen=main&ajaxaction=upgrade_building&type=main&h=${csrf_token}&&client_time=${+new Date}` + } + noColorSyntax(){ + + } +} \ No newline at end of file diff --git a/tests/cases/Issue382.ts b/tests/cases/Issue382.ts new file mode 100644 index 00000000..1f287aa5 --- /dev/null +++ b/tests/cases/Issue382.ts @@ -0,0 +1,16 @@ + + class ConstrainedBasedObjectcolection + { + public GetState(): { [index : string]: string } + { + if (this.ShouldFilter()) + return { fpn: this.CurrentFilter().PropertyOfDefinition.DisplayName, fpv: this.CuttrentFilter().FilterValue } + return {}; + } + + public CurrentFilter: knockoutObservable> = ko.observable>(); + + } + + + diff --git a/tests/cases/Issue383.tsx b/tests/cases/Issue383.tsx new file mode 100644 index 00000000..34605416 --- /dev/null +++ b/tests/cases/Issue383.tsx @@ -0,0 +1,13 @@ +// @onlyOwnGrammar - As this has jsx + +const singleLineArrow = (first: number, second: Set) => (
); + +const multilineArrow = (first: number, + second: number[], +) => (
); + +const multilineArrowWithGenericType = (first: number, + second: Set, +) => (
); + +const followup = (first: number, second: Set) => (
); \ No newline at end of file diff --git a/tests/cases/Issue384.ts b/tests/cases/Issue384.ts new file mode 100644 index 00000000..a04e2891 --- /dev/null +++ b/tests/cases/Issue384.ts @@ -0,0 +1,5 @@ +declare function foo(): any +declare function foo(): any + +export function X(): void +export as namespace Y \ No newline at end of file diff --git a/tests/cases/Issue387.ts b/tests/cases/Issue387.ts new file mode 100644 index 00000000..2e3b292f --- /dev/null +++ b/tests/cases/Issue387.ts @@ -0,0 +1,42 @@ +// +// Copyright 2016 Kary Foundation, Inc. +// Author: Pouya Kary +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. +// + +// +// --- IMPORTS -------------------------------------------------------------------- +// + + import * as readline from 'readline'; + +// +// --- READLINE ------------------------------------------------------------------- +// + + /** + * Reads a string from the command line + * ``` + * async function main ( ) { + * let name = await kary.terminal.input('Your name: ') + * console.log(`Hello, ${ name }!`) + * } + * ``` + */ + export async function input ( message = '' ) { + const readlineInterface = readline.createInterface({ + input: process.stdin, + output: process.stdout, + }) + return new Promise ( resolve => { + readlineInterface.question ( message , answer => { + readlineInterface.close( ); + resolve( answer ); + }); + }); + } + +// -------------------------------------------------------------------------------- \ No newline at end of file diff --git a/tests/cases/Issue388.ts b/tests/cases/Issue388.ts new file mode 100644 index 00000000..34f0dc34 --- /dev/null +++ b/tests/cases/Issue388.ts @@ -0,0 +1,6 @@ +export const fun = (param: ParamType): FunResult => { } + +export const fun = + (param: ParamType): + FunResult => { +} \ No newline at end of file diff --git a/tests/cases/Issue389.ts b/tests/cases/Issue389.ts new file mode 100644 index 00000000..8e526d19 --- /dev/null +++ b/tests/cases/Issue389.ts @@ -0,0 +1,4 @@ +[function () +{ + let foo; +}]; \ No newline at end of file diff --git a/tests/cases/Issue391.ts b/tests/cases/Issue391.ts new file mode 100644 index 00000000..10f01d3d --- /dev/null +++ b/tests/cases/Issue391.ts @@ -0,0 +1,26 @@ +var interface = require('./../interface'); +var ctrl = require('./controllers'); +var utils = require('./../utils'); +var Promise = require('bluebird'); +var deligate = require('./core'); +var log = require('./../log'); + +var constructor = deligate.then(function(bot) +{ + bot.sendMessage(110224344, 'here is the index'); + bot.on('message', function(message) + { + if(utils.telegram.is_command(message.text)) + { + ctrl.commands(message).catch(function(error_log) + { + bot.sendMessage(message.chat.id, interface.text.errors.redirect); + log.uncaughtException(error_log); + }); + } + }); + + return ' ? Telegram WebHook Set: Successfull!'; +}); + +module.exports = constructor; diff --git a/tests/cases/Issue393.ts b/tests/cases/Issue393.ts new file mode 100644 index 00000000..4f456d9a --- /dev/null +++ b/tests/cases/Issue393.ts @@ -0,0 +1,6 @@ +class ColorsBars extends React.Component { + constructor(...args) { + super(...args) + this.toggleEdit = this.toggleEdit.bind(this) + } +} \ No newline at end of file diff --git a/tests/cases/Issue394.ts b/tests/cases/Issue394.ts new file mode 100644 index 00000000..3c1930ea --- /dev/null +++ b/tests/cases/Issue394.ts @@ -0,0 +1,4 @@ + gulp.add('watch-' + (asset.name || asset.route), function () + { + gulp.watch('./modules/*' + asset.moduleRelativePath, ['build-' + (asset.name || asset.route)]); + }); \ No newline at end of file diff --git a/tests/cases/Issue396.ts b/tests/cases/Issue396.ts new file mode 100644 index 00000000..052e33e7 --- /dev/null +++ b/tests/cases/Issue396.ts @@ -0,0 +1,9 @@ +/* jshint esnext:true */ +let it = require('./it'); +it.execute(function* builder(options) { + let metaData = yield it.read(option.metaFile); + it.meta = yield it.parse(metaData, { + ICON: yield it.read(options.icon), + ICON64: (yield it.read(options.icon64)).base64() + }); +}); \ No newline at end of file diff --git a/tests/cases/Issue397.ts b/tests/cases/Issue397.ts new file mode 100644 index 00000000..30f88e0a --- /dev/null +++ b/tests/cases/Issue397.ts @@ -0,0 +1,2 @@ +const a = Math.max(...x); +const b = 2; \ No newline at end of file diff --git a/tests/cases/Issue398.ts b/tests/cases/Issue398.ts new file mode 100644 index 00000000..7330ad3b --- /dev/null +++ b/tests/cases/Issue398.ts @@ -0,0 +1 @@ +let x: Array<{ name: string, fn(): any, field: string }> \ No newline at end of file diff --git a/tests/cases/Issue402.ts b/tests/cases/Issue402.ts new file mode 100644 index 00000000..23794fa3 --- /dev/null +++ b/tests/cases/Issue402.ts @@ -0,0 +1,25 @@ +ipcMain.on('ELECTRON_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD', function (event, guestId, method, ...args) { + const guestContents = webContents.fromId(guestId) + if (guestContents == null) return + + if (canAccessWindow(event.sender, guestContents)) { + guestContents[method](...args) + } else { + console.error(`Blocked ${event.sender.getURL()} from calling ${method} on its opener.`) + } +}) + +ipcMain.on('ELECTRON_GUEST_WINDOW_MANAGER_WEB_CONTENTS_METHOD_SYNC', function (event, guestId, method, ...args) { + const guestContents = webContents.fromId(guestId) + if (guestContents == null) { + event.returnValue = null + return + } + + if (canAccessWindow(event.sender, guestContents)) { + event.returnValue = guestContents[method](...args) + } else { + console.error(`Blocked ${event.sender.getURL()} from calling ${method} on its opener.`) + event.returnValue = null + } +}) \ No newline at end of file diff --git a/tests/cases/Issue403IncorrectlyDetectedArrowTypeParameters.ts b/tests/cases/Issue403IncorrectlyDetectedArrowTypeParameters.ts new file mode 100644 index 00000000..9c1d33a7 --- /dev/null +++ b/tests/cases/Issue403IncorrectlyDetectedArrowTypeParameters.ts @@ -0,0 +1,22 @@ +e.ui.plugin.add("resizable", "grid", { + resize: function() { + var t = e(this).data("ui-resizable"), + n = t.options, + r = t.size, + i = t.originalSize, + s = t.originalPosition, + o = t.axis, + u = typeof n.grid == "number" ? [n.grid, n.grid] : n.grid, + a = u[0] || 1, + f = u[1] || 1, + l = Math.round((r.width - i.width) / a) * a, + c = Math.round((r.height - i.height) / f) * f, + h = i.width + l, + p = i.height + c, + d = n.maxWidth && n.maxWidth < h, + v = n.maxHeight && n.maxHeight < p, + m = n.minWidth && n.minWidth > h, + g = n.minHeight && n.minHeight > p; + n.grid = u, m && (h += a), g && (p += f), d && (h -= a), v && (p -= f), /^(se|s|e)$/.test(o) ? (t.size.width = h, t.size.height = p) : /^(ne)$/.test(o) ? (t.size.width = h, t.size.height = p, t.position.top = s.top - c) : /^(sw)$/.test(o) ? (t.size.width = h, t.size.height = p, t.position.left = s.left - l) : (p - f > 0 ? (t.size.height = p, t.position.top = s.top - c) : (t.size.height = f, t.position.top = s.top + i.height - f), h - a > 0 ? (t.size.width = h, t.position.left = s.left - l) : (t.size.width = a, t.position.left = s.left + i.width - a)) + } + }) \ No newline at end of file diff --git a/tests/cases/Issue403IncorrectlyDetectedFunctionCallAsArrow.ts b/tests/cases/Issue403IncorrectlyDetectedFunctionCallAsArrow.ts new file mode 100644 index 00000000..d4f8eb24 --- /dev/null +++ b/tests/cases/Issue403IncorrectlyDetectedFunctionCallAsArrow.ts @@ -0,0 +1,8 @@ +p.parseJSON = function(t) { + if (e.JSON && e.JSON.parse) return e.JSON.parse(t + ""); + var n, r = null, + i = p.trim(t + ""); + return i && !p.trim(i.replace(Nn, function(e, t, i, s) { + return n && t && (r = 0), r === 0 ? e : (n = i || t, r += !s - !i, "") + })) ? Function("return " + i)() : p.error("Invalid JSON: " + t) + } \ No newline at end of file diff --git a/tests/cases/Issue405.ts b/tests/cases/Issue405.ts new file mode 100644 index 00000000..a2b68f08 --- /dev/null +++ b/tests/cases/Issue405.ts @@ -0,0 +1,13 @@ +function myFunction1 + (a: string) +{ + var r = true; + return true +} + +function myFunction2 + (a: string): boolean +{ + var r = true; + return true +} diff --git a/tests/cases/Issue407.ts b/tests/cases/Issue407.ts new file mode 100644 index 00000000..3e4c849c --- /dev/null +++ b/tests/cases/Issue407.ts @@ -0,0 +1,2 @@ +let x: Map; +let Y: Map; \ No newline at end of file diff --git a/tests/cases/Issue408.ts b/tests/cases/Issue408.ts new file mode 100644 index 00000000..ce4fdb42 --- /dev/null +++ b/tests/cases/Issue408.ts @@ -0,0 +1,2 @@ +assert(truthyValue, 'must be true'); +path(pathArgs); \ No newline at end of file diff --git a/tests/cases/Issue415.tsx b/tests/cases/Issue415.tsx new file mode 100644 index 00000000..f6716b9e --- /dev/null +++ b/tests/cases/Issue415.tsx @@ -0,0 +1,8 @@ +// @onlyOwnGrammar - As this has jsx +(); +(); +(); +(); +(); +(); +(bold); \ No newline at end of file diff --git a/tests/cases/Issue417.ts b/tests/cases/Issue417.ts new file mode 100644 index 00000000..18688157 --- /dev/null +++ b/tests/cases/Issue417.ts @@ -0,0 +1,4 @@ +const a = { + 1: '1', + '2': '2', +} \ No newline at end of file diff --git a/tests/cases/Issue418.ts b/tests/cases/Issue418.ts new file mode 100644 index 00000000..166a7004 --- /dev/null +++ b/tests/cases/Issue418.ts @@ -0,0 +1,21 @@ +function merge(as, bs) { + let res = [] + let ia = 0 + let ib = 0 + while (ia < as.length && ib < bs.length) { // coloring broken + if (as[ia] < bs[ib]) { + res.push(as[ia++]) // coloring broken + } else { + res.push(bs[ib++]) // coloring broken + } + } + return res.concat(as.slice(ia)).concat(bs.slice(ib)) // coloring broken +} + +function mergesort(array) { + if (array.length < 2) { + return array + } + const mid = Math.floor(array.length / 2) + return merge(mergesort(array.slice(0, mid)), mergesort(array.slice(mid))) +} \ No newline at end of file diff --git a/tests/cases/Issue42.ts b/tests/cases/Issue42.ts new file mode 100644 index 00000000..2d8a0d1d --- /dev/null +++ b/tests/cases/Issue42.ts @@ -0,0 +1,4 @@ + return this.travelWorld((cell: Cell) => { + cell.live = Math.random() < this.initialLifeProbability; + return cell; + }); \ No newline at end of file diff --git a/tests/cases/Issue420.ts b/tests/cases/Issue420.ts new file mode 100644 index 00000000..4b5c193d --- /dev/null +++ b/tests/cases/Issue420.ts @@ -0,0 +1,4 @@ +verify.quickInfos({ + 1: "this: ContextualInterface", + 2: "(parameter) this: void" +}); \ No newline at end of file diff --git a/tests/cases/Issue421.ts b/tests/cases/Issue421.ts new file mode 100644 index 00000000..5484d621 --- /dev/null +++ b/tests/cases/Issue421.ts @@ -0,0 +1,5 @@ +function f( + arg: 'x' | + 'y', + arg2: 1 | + 2) {} \ No newline at end of file diff --git a/tests/cases/Issue423.ts b/tests/cases/Issue423.ts new file mode 100644 index 00000000..a57258be --- /dev/null +++ b/tests/cases/Issue423.ts @@ -0,0 +1,8 @@ +interface Foo { + bar: string; +} + +type T = Foo; // line 5 +interface Bar { + foo: Foo; // line 7 +} \ No newline at end of file diff --git a/tests/cases/Issue427.ts b/tests/cases/Issue427.ts new file mode 100644 index 00000000..b122d225 --- /dev/null +++ b/tests/cases/Issue427.ts @@ -0,0 +1,3 @@ +function a(): { [key: string]: number } | { [key: string]: number } { throw 1 } + +function b(a: { [key: string]: number } | { [key: string]: number }): void { } \ No newline at end of file diff --git a/tests/cases/Issue428.ts b/tests/cases/Issue428.ts new file mode 100644 index 00000000..1aa5874f --- /dev/null +++ b/tests/cases/Issue428.ts @@ -0,0 +1,11 @@ +export function funct + (a: number): string + +export function funct + (a: number): number + +// this is implementation +export function funct + (a: number): any { + + } \ No newline at end of file diff --git a/tests/cases/Issue43.ts b/tests/cases/Issue43.ts new file mode 100644 index 00000000..fea95cbe --- /dev/null +++ b/tests/cases/Issue43.ts @@ -0,0 +1,2 @@ +var $this = $(this); +$this.addClass("hehe"); \ No newline at end of file diff --git a/tests/cases/Issue430.tsx b/tests/cases/Issue430.tsx new file mode 100644 index 00000000..966ab586 --- /dev/null +++ b/tests/cases/Issue430.tsx @@ -0,0 +1,10 @@ +// @onlyOwnGrammar - As this has jsx +class c { +render() { + return this.props.data.weekDays.filter((weekDay, index) => (this.state.showAll || index < 3)).map((weekDay, key) => ( +

+ {weekDay.label} {this.props.data[weekDay.id].start} - {this.props.data[weekDay.id].finish} +

+ )) + } +} \ No newline at end of file diff --git a/tests/cases/Issue431.ts b/tests/cases/Issue431.ts new file mode 100644 index 00000000..1196c878 --- /dev/null +++ b/tests/cases/Issue431.ts @@ -0,0 +1,4 @@ +myFunc +(...argName) + +function otherFunc() {} // <-- Not highlighted. \ No newline at end of file diff --git a/tests/cases/Issue433.ts b/tests/cases/Issue433.ts new file mode 100644 index 00000000..ee80171a --- /dev/null +++ b/tests/cases/Issue433.ts @@ -0,0 +1,3 @@ +declare module ILogin{ + export interface Z {} +} \ No newline at end of file diff --git a/tests/cases/Issue434.ts b/tests/cases/Issue434.ts new file mode 100644 index 00000000..a7f48c7f --- /dev/null +++ b/tests/cases/Issue434.ts @@ -0,0 +1,21 @@ +export class SomeClass { + private someMethod(): void { + if (1 + < 2) { + console.log("TypeScript syntax highlighting is broken!"); + } + else if (1 > 2) { + console.log(""); + } + } + + private someOtherMethod() { + console.log(""); + // + const q = 1; + var s = 2; + let e = 3; + } + + q = 100; +} \ No newline at end of file diff --git a/tests/cases/Issue435.ts b/tests/cases/Issue435.ts new file mode 100644 index 00000000..cc782744 --- /dev/null +++ b/tests/cases/Issue435.ts @@ -0,0 +1,7 @@ +/** + * Manually add an item to the uploading queue. + * + * @param {PIXI.DisplayObject|PIXI.Container|PIXI.BaseTexture|PIXI.Texture|PIXI.Graphics|PIXI.Text|*} item - Object to + * add to the queue + * @return {PIXI.CanvasPrepare} Instance of plugin for chaining. + */ \ No newline at end of file diff --git a/tests/cases/Issue44.ts b/tests/cases/Issue44.ts index 16c576ac..13c077d9 100644 --- a/tests/cases/Issue44.ts +++ b/tests/cases/Issue44.ts @@ -1,8 +1,8 @@ -^^interface ^^TestInterface { - ^^testvar: ^^string; - ^^testfunc(): ^^string; -^^} +interface TestInterface { + testvar: string; + testfunc(): string; +} /* Testing Comments diff --git a/tests/cases/Issue441.ts b/tests/cases/Issue441.ts new file mode 100644 index 00000000..a6544561 --- /dev/null +++ b/tests/cases/Issue441.ts @@ -0,0 +1,2 @@ +func(1) +async(1) \ No newline at end of file diff --git a/tests/cases/Issue444.ts b/tests/cases/Issue444.ts new file mode 100644 index 00000000..4bc5bb6d --- /dev/null +++ b/tests/cases/Issue444.ts @@ -0,0 +1,9 @@ +var test = "123 456"; + +if ((test.match(/\d+/g)[0]) / (test.match(/\d+/g)[1]) < 1) { + return; +} + +if ((test.match(/\d+/g)[0])/(test.match(/\d+/g)[1]) < 1) { + return; +} \ No newline at end of file diff --git a/tests/cases/Issue445.ts b/tests/cases/Issue445.ts new file mode 100644 index 00000000..5a530fac --- /dev/null +++ b/tests/cases/Issue445.ts @@ -0,0 +1,8 @@ +/** + * My awesome function. + * @param {{id: string, name: string}} object An object with an id and name field. + */ +function myAwesomeFunction(object) { + const { name, id } = object. + // do stuff with name and id +} \ No newline at end of file diff --git a/tests/cases/Issue450.ts b/tests/cases/Issue450.ts new file mode 100644 index 00000000..976b7369 --- /dev/null +++ b/tests/cases/Issue450.ts @@ -0,0 +1,2 @@ +// @onlyOwnGrammar - As this has type assertion +let a = true ? 1 : 2; \ No newline at end of file diff --git a/tests/cases/Issue452.ts b/tests/cases/Issue452.ts new file mode 100644 index 00000000..c9c95a55 --- /dev/null +++ b/tests/cases/Issue452.ts @@ -0,0 +1,7 @@ +class Test{} +class Favorite extends Test< + string | number, + undefined +> { + // class content +} \ No newline at end of file diff --git a/tests/cases/Issue453.ts b/tests/cases/Issue453.ts new file mode 100644 index 00000000..0ad57844 --- /dev/null +++ b/tests/cases/Issue453.ts @@ -0,0 +1,11 @@ +type Resolve = () => number; + +class Test { + first(values: Map): number { + return values.has('a') ? values.get('a')!() : 0; + } + + second(): string { + return 'foo'; + } +} \ No newline at end of file diff --git a/tests/cases/Issue455.ts b/tests/cases/Issue455.ts new file mode 100644 index 00000000..0f46f60a --- /dev/null +++ b/tests/cases/Issue455.ts @@ -0,0 +1,7 @@ +func(function () // } +{ + if (false) + return 1 + else + return 2 +}); \ No newline at end of file diff --git a/tests/cases/Issue458.ts b/tests/cases/Issue458.ts new file mode 100644 index 00000000..b754eec6 --- /dev/null +++ b/tests/cases/Issue458.ts @@ -0,0 +1,6 @@ +export class Blah { + get () {} +} +const x = { + get () {} +} \ No newline at end of file diff --git a/tests/cases/Issue460.ts b/tests/cases/Issue460.ts new file mode 100644 index 00000000..ca620b9d --- /dev/null +++ b/tests/cases/Issue460.ts @@ -0,0 +1,2 @@ +// single-line comment +/* multi-line comment */ \ No newline at end of file diff --git a/tests/cases/Issue461.tsx b/tests/cases/Issue461.tsx new file mode 100644 index 00000000..e90cbd4b --- /dev/null +++ b/tests/cases/Issue461.tsx @@ -0,0 +1,13 @@ +// @onlyOwnGrammar - As this has jsx +class Foo { + renderProgress = () => + x + + render () { + return ( +
+ {!this.state.loaded && this.renderProgress()} +
+ ) + } +} \ No newline at end of file diff --git a/tests/cases/Issue463.ts b/tests/cases/Issue463.ts new file mode 100644 index 00000000..ce79bed1 --- /dev/null +++ b/tests/cases/Issue463.ts @@ -0,0 +1,3 @@ +const x = + 1 +if (x) return x \ No newline at end of file diff --git a/tests/cases/Issue466.ts b/tests/cases/Issue466.ts new file mode 100644 index 00000000..a0f7a511 --- /dev/null +++ b/tests/cases/Issue466.ts @@ -0,0 +1,3 @@ +function foo(this: number, x: number) { + +} \ No newline at end of file diff --git a/tests/cases/Issue468.ts b/tests/cases/Issue468.ts new file mode 100644 index 00000000..7fbd3419 --- /dev/null +++ b/tests/cases/Issue468.ts @@ -0,0 +1 @@ +({ 'foo\'': 'bar' }) \ No newline at end of file diff --git a/tests/cases/Issue470.ts b/tests/cases/Issue470.ts new file mode 100644 index 00000000..3d7f8024 --- /dev/null +++ b/tests/cases/Issue470.ts @@ -0,0 +1 @@ +var x = await import("./file1"); \ No newline at end of file diff --git a/tests/cases/Issue471.ts b/tests/cases/Issue471.ts new file mode 100644 index 00000000..b2e020b6 --- /dev/null +++ b/tests/cases/Issue471.ts @@ -0,0 +1,5 @@ +const foo = + true || `${'hello'}.txt` + +function syntaxHighlightingIsBroken() { +} \ No newline at end of file diff --git a/tests/cases/Issue472.ts b/tests/cases/Issue472.ts new file mode 100644 index 00000000..bc2a7702 --- /dev/null +++ b/tests/cases/Issue472.ts @@ -0,0 +1,9 @@ +interface I { + bar1: { + quantity: string + }, + bar2: + { + quantity: string + } +} \ No newline at end of file diff --git a/tests/cases/Issue476.ts b/tests/cases/Issue476.ts new file mode 100644 index 00000000..54fe63cd --- /dev/null +++ b/tests/cases/Issue476.ts @@ -0,0 +1,14 @@ +class Bug { + static asdf(o, o2) { + Bug.asdf("", '`') + return { + [ + "a" + ]: + [ + Bug.asdf("", '`') + ] + }; + } + +} \ No newline at end of file diff --git a/tests/cases/Issue477.ts b/tests/cases/Issue477.ts new file mode 100644 index 00000000..c1415151 --- /dev/null +++ b/tests/cases/Issue477.ts @@ -0,0 +1,19 @@ +function* fn1() {} +function * fn2() {} +function *fn3() {} + +const foo = { + * fn4() {}, + *fn5() {}, + fn6: function*() {}, // Incorrect + fn7: function* () {}, // Incorrect + fn8: function *() {}, +} + +class Bar { + * fn9() {} + *fn10() {} + fn11 = function*() {} // Incorrect + fn12 = function* () {} // Incorrect + fn13 = function *() {} +} \ No newline at end of file diff --git a/tests/cases/Issue478.tsx b/tests/cases/Issue478.tsx new file mode 100644 index 00000000..e8363c37 --- /dev/null +++ b/tests/cases/Issue478.tsx @@ -0,0 +1,15 @@ +// Before +a = (b: string, c: number) => { + console.log(b, c); +} + +d = (e: string) => ( + f: G +) => { + console.log(e, f); +}; + +// After +a = (b: string, c: number) => { + console.log(b, c); +} \ No newline at end of file diff --git a/tests/cases/Issue480.ts b/tests/cases/Issue480.ts new file mode 100644 index 00000000..b3a6d57d --- /dev/null +++ b/tests/cases/Issue480.ts @@ -0,0 +1,11 @@ +/* @internal */ +export interface Pattern { + prefix: string; + suffix: string; +} + +// @internal +export interface Pattern2 { + prefix: string; + suffix: string; +} \ No newline at end of file diff --git a/tests/cases/Issue482.ts b/tests/cases/Issue482.ts new file mode 100644 index 00000000..e8ec1de0 --- /dev/null +++ b/tests/cases/Issue482.ts @@ -0,0 +1,3 @@ +let a = 1; +let b = [new Object] +let c = 1 \ No newline at end of file diff --git a/tests/cases/Issue484.ts b/tests/cases/Issue484.ts new file mode 100644 index 00000000..8f404a92 --- /dev/null +++ b/tests/cases/Issue484.ts @@ -0,0 +1,6 @@ +declare module 'foo'; +declare module 'bar'; +declare module 'baz'; +interface Foo { + bar: string; +} \ No newline at end of file diff --git a/tests/cases/Issue485.ts b/tests/cases/Issue485.ts new file mode 100644 index 00000000..78bab949 --- /dev/null +++ b/tests/cases/Issue485.ts @@ -0,0 +1,2 @@ +import a from 'a' // test +import b from 'b' \ No newline at end of file diff --git a/tests/cases/Issue486.ts b/tests/cases/Issue486.ts new file mode 100644 index 00000000..82887843 --- /dev/null +++ b/tests/cases/Issue486.ts @@ -0,0 +1,3 @@ +const C = class { + private data = 0; +} \ No newline at end of file diff --git a/tests/cases/Issue491.ts b/tests/cases/Issue491.ts new file mode 100644 index 00000000..351cd9e4 --- /dev/null +++ b/tests/cases/Issue491.ts @@ -0,0 +1,4 @@ +let a: number = w, +b: string = x, // string is not colored +c: any = y, // any is not colored +d: boolean = z; // boolean is not colored \ No newline at end of file diff --git a/tests/cases/Issue496.ts b/tests/cases/Issue496.ts new file mode 100644 index 00000000..f14d1893 --- /dev/null +++ b/tests/cases/Issue496.ts @@ -0,0 +1,4 @@ +// @onlyOwnGrammar - As this has cast expression +var x = 0; +var y = 1; +var z = x + y; \ No newline at end of file diff --git a/tests/cases/Issue499.ts b/tests/cases/Issue499.ts new file mode 100644 index 00000000..556886f8 --- /dev/null +++ b/tests/cases/Issue499.ts @@ -0,0 +1,5 @@ +const fn = ({ + arg = [], +}) => { + return "This line should be highlighted correctly"; +} \ No newline at end of file diff --git a/tests/cases/Issue5.ts b/tests/cases/Issue5.ts index 3a0ae66c..bc6dfd5f 100644 --- a/tests/cases/Issue5.ts +++ b/tests/cases/Issue5.ts @@ -1,34 +1,34 @@ -let new_string = ^^"^^New Changes" -^^ +let new_string = "New Changes" + let plain_double_text = "Hello\ -this link to github is^^ https://github.com/\ -hello^^\ +this link to github is https://github.com/\ +hello\ World" -let plain_single_text= ^^'Try with single bracket\ -hello world ^^\\\\\ +let plain_single_text= 'Try with single bracket\ +hello world \\\\\ let this be ^\ a good test ^' -let double_quote_issue = " ^^ qstring-double:\ - ^^name: ^^string.double.ts^^\ - ^^begin: ^^\'\"\'\ - ^^end: ^^\'\"|(?:[^\r\n\\]$)'\ - ^^patterns:^^\ - ^^- include: ^^'#string-character-escape'^^\ - ^^" -^^ -let single_quote_issue = '^^qstring-single:^^\ - ^^name: string.single.ts^^\ - ^^begin: \"\'\"\ - ^^end: \'|(?:[^\r\n\\]$)^^\ - ^^endCaptures:^^\ - ^^ '0': {name: string-character-escape }^^\ - ^^patterns:^^\ - ^^- include: \'#string-character-escape\'^^\ - ^^' -^^ -let new_string = ^^"^^Changes End here^^" -^^ +let double_quote_issue = " qstring-double:\ + name: string.double.ts\ + begin: \'\"\'\ + end: \'\"|(?:[^\r\n\\]$)'\ + patterns:\ + - include: '#string-character-escape'\ + " + +let single_quote_issue = 'qstring-single:\ + name: string.single.ts\ + begin: \"\'\"\ + end: \'|(?:[^\r\n\\]$)\ + endCaptures:\ + '0': {name: string-character-escape }\ + patterns:\ + - include: \'#string-character-escape\'\ + ' + +let new_string = "Changes End here" + diff --git a/tests/cases/Issue500.ts b/tests/cases/Issue500.ts new file mode 100644 index 00000000..1ae2df72 --- /dev/null +++ b/tests/cases/Issue500.ts @@ -0,0 +1 @@ +0 as any as string; \ No newline at end of file diff --git a/tests/cases/Issue502.ts b/tests/cases/Issue502.ts new file mode 100644 index 00000000..ab845aa1 --- /dev/null +++ b/tests/cases/Issue502.ts @@ -0,0 +1,6 @@ +class Foo { + bar () { + [...this.foobar()]; + [... this.foobar()]; + } +} \ No newline at end of file diff --git a/tests/cases/Issue506.ts b/tests/cases/Issue506.ts new file mode 100644 index 00000000..06b2756a --- /dev/null +++ b/tests/cases/Issue506.ts @@ -0,0 +1,9 @@ + if (platform.isWindows) { + this._processReady.then(() => { + if (!this._isDisposed) { + import('vs/workbench/parts/terminal/electron-browser/windowsShellHelper').then((module) => { + this._windowsShellHelper = new module.WindowsShellHelper(this._processId, this._shellLaunchConfig.executable, this, this._xterm); + }); + } + }); + } \ No newline at end of file diff --git a/tests/cases/Issue510.ts b/tests/cases/Issue510.ts new file mode 100644 index 00000000..501fb423 --- /dev/null +++ b/tests/cases/Issue510.ts @@ -0,0 +1,33 @@ + // Factory functions + + const createZombie = ({ + status = 1, + width = 10, + height = 10, + xPosition, + yPosition, + color = "green" + }) => ({ + status, + width, + height, + xPosition, + yPosition, + color + }); + + const createHero = ({ + status = 1, + width = 25, + height = 50, + xPosition, + yPosition, + color = "red" + }) => ({ + status, + width, + height, + xPosition, + yPosition, + color + }); \ No newline at end of file diff --git a/tests/cases/Issue513.ts b/tests/cases/Issue513.ts new file mode 100644 index 00000000..41a7a7a0 --- /dev/null +++ b/tests/cases/Issue513.ts @@ -0,0 +1 @@ +(/a/u); \ No newline at end of file diff --git a/tests/cases/Issue515.ts b/tests/cases/Issue515.ts new file mode 100644 index 00000000..104d477c --- /dev/null +++ b/tests/cases/Issue515.ts @@ -0,0 +1,9 @@ +/** + * @param {boolean} [settings.debug= - Print getUpdate results in console. + */ +/** + * @param {boolean} [settings.debug=] - Print getUpdate results in console. + */ +/** + * @param {boolean} [settings.debug=1] - Print getUpdate results in console. + */ diff --git a/tests/cases/Issue518.tsx b/tests/cases/Issue518.tsx new file mode 100644 index 00000000..e4f6c601 --- /dev/null +++ b/tests/cases/Issue518.tsx @@ -0,0 +1,2 @@ +// @onlyOwnGrammar - As this has jsx +(= 2 && i < 3 ? "first branch" : i > (j - 2) * 4 ? "second branch" : "third branch" } />) \ No newline at end of file diff --git a/tests/cases/Issue521.ts b/tests/cases/Issue521.ts new file mode 100644 index 00000000..322f945f --- /dev/null +++ b/tests/cases/Issue521.ts @@ -0,0 +1,2 @@ +const names = results.f(result.success ? (2) : 2).f(c => c.name) +const a = 1; \ No newline at end of file diff --git a/tests/cases/Issue522.ts b/tests/cases/Issue522.ts new file mode 100644 index 00000000..ece571f1 --- /dev/null +++ b/tests/cases/Issue522.ts @@ -0,0 +1,14 @@ +const brokenSyntaxHighlighting = () => { + const array = a?.b?.c?.d?.g; + + /** + * No TypeEror, but syntax highlighting is broken + */ + const test = a?.b?.f?.f; + + for (let i = 0; i < array.length; i++) { + console.log(array[i]); + } +}; + +brokenSyntaxHighlighting(); \ No newline at end of file diff --git a/tests/cases/Issue525.ts b/tests/cases/Issue525.ts new file mode 100644 index 00000000..f56e11cd --- /dev/null +++ b/tests/cases/Issue525.ts @@ -0,0 +1,2 @@ +map(result.success ? (a) : 1).map(c => c.name) +const a = 1; \ No newline at end of file diff --git a/tests/cases/Issue526.ts b/tests/cases/Issue526.ts new file mode 100644 index 00000000..36dd8c66 --- /dev/null +++ b/tests/cases/Issue526.ts @@ -0,0 +1,5 @@ +if (a++ < b) { +} + +export class A extends B { +} \ No newline at end of file diff --git a/tests/cases/Issue530.ts b/tests/cases/Issue530.ts new file mode 100644 index 00000000..d761a037 --- /dev/null +++ b/tests/cases/Issue530.ts @@ -0,0 +1,8 @@ +function getStats() { + const query = query<[number], number>(` + SELECT * + FROM statistics + WHERE unit_id = $1`) + + return database.execute(query, [id]) +} \ No newline at end of file diff --git a/tests/cases/Issue531.ts b/tests/cases/Issue531.ts new file mode 100644 index 00000000..ce33d333 --- /dev/null +++ b/tests/cases/Issue531.ts @@ -0,0 +1,4 @@ +class Test { } +export { + Test as default +}; \ No newline at end of file diff --git a/tests/cases/Issue536.ts b/tests/cases/Issue536.ts new file mode 100644 index 00000000..9d71d47f --- /dev/null +++ b/tests/cases/Issue536.ts @@ -0,0 +1 @@ +const z = (() => {})() \ No newline at end of file diff --git a/tests/cases/Issue538.ts b/tests/cases/Issue538.ts new file mode 100644 index 00000000..5de0022d --- /dev/null +++ b/tests/cases/Issue538.ts @@ -0,0 +1,2 @@ +declare function f(): void; +const x = f<"a", "b">(); \ No newline at end of file diff --git a/tests/cases/Issue540.ts b/tests/cases/Issue540.ts new file mode 100644 index 00000000..54bc283b --- /dev/null +++ b/tests/cases/Issue540.ts @@ -0,0 +1,40 @@ +// 1. Correct highlighting +doSomething = (param, { a = "default" } = {}) => { + //noop +} + +// 2. Incorrect highlighting - limitation of grammar +doSomething = (param, { + a = "default" +} = {}) => { + //noop +} + +// 3. Correct highlighting +doSomething(param, { + a = "default" +} = {}) { + //noop +} + +// 4. Correct highlighting +doSomething(param, { a = "default" } = {}) { + //noop +} + +// 5. Correct highlighting (notice config module) +doSomething(param, { + a = config.get("a") +} = {}) { + //noop +} + +// 6. Correct highlighting (notice config module) +doSomething(param, { a = config.get("a") } = {}) { + //noop +} + +// 7. Incorrect highlighting (notice config module) while 1. does +doSomething = (param, { a = config.get("a") } = {}) => { + //noop +} \ No newline at end of file diff --git a/tests/cases/Issue543.ts b/tests/cases/Issue543.ts new file mode 100644 index 00000000..55ec185f --- /dev/null +++ b/tests/cases/Issue543.ts @@ -0,0 +1,5 @@ +// @onlyOwnGrammar - As this has cast +let x = -5; +x = --x; +x = +x; +1 && 2 & 3 | 4 + 5 ^ 6 && (5) \ No newline at end of file diff --git a/tests/cases/Issue549.ts b/tests/cases/Issue549.ts new file mode 100644 index 00000000..80285022 --- /dev/null +++ b/tests/cases/Issue549.ts @@ -0,0 +1,5 @@ +function foo(x, y){ + if(x < y || (x > (y))){ + } + return 'of the jedi'; +} \ No newline at end of file diff --git a/tests/cases/Issue550.ts b/tests/cases/Issue550.ts new file mode 100644 index 00000000..d0fb085d --- /dev/null +++ b/tests/cases/Issue550.ts @@ -0,0 +1,11 @@ +export const foo = (firstVariable: string, secondVariable: number): string => { + return "foo" +} + +export const bar = ( + firstVariable: string, + secondVariable: number, + thirdVariable: string +): string => { + return "baz" +} \ No newline at end of file diff --git a/tests/cases/Issue551.ts b/tests/cases/Issue551.ts new file mode 100644 index 00000000..143b32b8 --- /dev/null +++ b/tests/cases/Issue551.ts @@ -0,0 +1,5 @@ +class a extends b, c { +} +class a2 extends b, c +{ +} \ No newline at end of file diff --git a/tests/cases/Issue554.ts b/tests/cases/Issue554.ts new file mode 100644 index 00000000..c9264207 --- /dev/null +++ b/tests/cases/Issue554.ts @@ -0,0 +1,8 @@ +async function f(x: Promise) { + return { ...await x }; +} +...new Object() +...function f() {} +...typeof x +...void x +...undefined \ No newline at end of file diff --git a/tests/cases/Issue556.ts b/tests/cases/Issue556.ts new file mode 100644 index 00000000..66e82839 --- /dev/null +++ b/tests/cases/Issue556.ts @@ -0,0 +1,4 @@ +class Thing { + foo: SomeFunc = () => void 0; + bar = () => void 0; +} \ No newline at end of file diff --git a/tests/cases/Issue558.ts b/tests/cases/Issue558.ts new file mode 100644 index 00000000..b5f0fb64 --- /dev/null +++ b/tests/cases/Issue558.ts @@ -0,0 +1,13 @@ +export const interview = async ( + fabricatedCase : FabricatedCase +) : Promise => { + const res = await fetch(API_URL + '/interviews', { + method: 'POST', + headers: new Headers({ + 'Content-Type': 'application/json', + }), + body: JSON.stringify(fabricatedTest), + }); + const interviewTest = await res.json(); + return interviewTest; +}; \ No newline at end of file diff --git a/tests/cases/Issue559.ts b/tests/cases/Issue559.ts new file mode 100644 index 00000000..f333faa8 --- /dev/null +++ b/tests/cases/Issue559.ts @@ -0,0 +1,7 @@ +let myFunc = function(txt:string,num:number){} + +class MyClass { + myProp = myFunc void>("syntax highlight is incorrect", 1); +} + +let myProp = myFunc void>("syntax highlight is correct here", 1); \ No newline at end of file diff --git a/tests/cases/Issue562.ts b/tests/cases/Issue562.ts new file mode 100644 index 00000000..873f1f49 --- /dev/null +++ b/tests/cases/Issue562.ts @@ -0,0 +1,11 @@ +// @onlyOwnGrammar - As this has cast +yield 10; +(yield 10); +function foo() { + return 10; +} +topYields.sort ((share1,share2) => { + if (share1.yield < share2.yield) { return 1; } + if (share1.yield > share2.yield) { return -1; } + return 0; + }); diff --git a/tests/cases/Issue566.ts b/tests/cases/Issue566.ts new file mode 100644 index 00000000..0842b89a --- /dev/null +++ b/tests/cases/Issue566.ts @@ -0,0 +1,41 @@ +const COULOMB = 8.957_551_787e9; // N-m^2 / C^2 +const PLANCK = 6.626_070_040e-34; // J-s +const JENNY = 867_5309; // C-A-L^2 +let bits = 0b1100_1100; +let routine = 0xC0FFEE_F00D_BED; + +1_000_000_000 +1.1_00_01 +1e1_0 +1e+1_0 +1e-1_0 +1.1e10_0 +1.1e+10_0 +1.1e-10_0 +12_34_56 +1_22_333 +1_2.3_4 +1_2.3_4e5_6 +1_2.3_4e+5_6 +1_2.3_4e-5_6 + +0x00_11; +0X0_1; +0x1100_0011; +0X0_11_0101; + +0o00_11; +0O0_1; +0o1100_0011; +0O0_11_0101; + +0b00_11; +0B0_1; +0b1100_0011; +0B0_11_0101; + +// Verify the following are not classified as a number +_1_2; +0b_1; +0x_1; +0o_1; diff --git a/tests/cases/Issue567.ts b/tests/cases/Issue567.ts new file mode 100644 index 00000000..600b206c --- /dev/null +++ b/tests/cases/Issue567.ts @@ -0,0 +1,2 @@ +function t(){ +return e.call(this,[t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),"-",t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),"-","4",t._randomHex(),t._randomHex(),t._randomHex(),"-",t._oneOf(t._timeHighBits),t._randomHex(),t._randomHex(),t._randomHex(),"-",t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex(),t._randomHex()].join(""))||this} \ No newline at end of file diff --git a/tests/cases/Issue569.ts b/tests/cases/Issue569.ts new file mode 100644 index 00000000..9fb43401 --- /dev/null +++ b/tests/cases/Issue569.ts @@ -0,0 +1,2 @@ +export { default as x } +export { x as default } \ No newline at end of file diff --git a/tests/cases/Issue571.ts b/tests/cases/Issue571.ts new file mode 100644 index 00000000..8751dff7 --- /dev/null +++ b/tests/cases/Issue571.ts @@ -0,0 +1,10 @@ +const o = { + ["a" + + "b"]() { + return 0; // no highlighting! + }, + 'a\ + '() { + return 0; // no highlighting! + } +}; \ No newline at end of file diff --git a/tests/cases/Issue572.ts b/tests/cases/Issue572.ts new file mode 100644 index 00000000..2b15cad2 --- /dev/null +++ b/tests/cases/Issue572.ts @@ -0,0 +1,3 @@ +function /*like here*/ * foo() { + yield /*or here*/* [42]; +} \ No newline at end of file diff --git a/tests/cases/Issue572ForLoop.ts b/tests/cases/Issue572ForLoop.ts new file mode 100644 index 00000000..fbb53099 --- /dev/null +++ b/tests/cases/Issue572ForLoop.ts @@ -0,0 +1,5 @@ +/*0*/ for /*1*/ ( /*2*/ var /*3*/ x /*4*/ in /*5*/ a /*6*/) /*7*/{} +/*0*/ for /*1*/ ( /*2*/ var /*3*/ x /*4*/ of /*5*/ a /*6*/) /*7*/{} +/*0*/ for /*1*/ ( /*3*/ x /*4*/ in /*5*/ a /*6*/) /*7*/ {} +/*0*/ for /*1*/ ( /*3*/ x /*4*/ of /*5*/ a /*6*/) /*7*/ {} +/*0*/ for /*1*/ ( /*2*/ a /*3*/ ; /*4*/ a /*5*/ ; /*6*/ a /*7*/) /*8*/ {} \ No newline at end of file diff --git a/tests/cases/Issue575.ts b/tests/cases/Issue575.ts new file mode 100644 index 00000000..b47d69a1 --- /dev/null +++ b/tests/cases/Issue575.ts @@ -0,0 +1,6 @@ +function runQuery() { + const query = createQuery<[number[]], Table>(` + some SQL here + `) + return database.execute(query) +} \ No newline at end of file diff --git a/tests/cases/Issue578.ts b/tests/cases/Issue578.ts new file mode 100644 index 00000000..4eef28bc --- /dev/null +++ b/tests/cases/Issue578.ts @@ -0,0 +1,5 @@ +if (targetAttribute) { + if (!(targetAttribute instanceof Attribute)) { + targetAttribute = new Attribute(targetAttribute); + } +} \ No newline at end of file diff --git a/tests/cases/Issue579.ts b/tests/cases/Issue579.ts new file mode 100644 index 00000000..0b977006 --- /dev/null +++ b/tests/cases/Issue579.ts @@ -0,0 +1,4 @@ +function f(): (x: number) => any { + return true ? x => f() : x => 0; +} +const x = 0; // no highlight in rest of file \ No newline at end of file diff --git a/tests/cases/Issue580.ts b/tests/cases/Issue580.ts new file mode 100644 index 00000000..2e0e6dfd --- /dev/null +++ b/tests/cases/Issue580.ts @@ -0,0 +1 @@ +(a[0] / 2) / (2) \ No newline at end of file diff --git a/tests/cases/Issue581.ts b/tests/cases/Issue581.ts new file mode 100644 index 00000000..9e698e16 --- /dev/null +++ b/tests/cases/Issue581.ts @@ -0,0 +1,4 @@ +interface Foo { + a: () => void; + b?: () => void; +} \ No newline at end of file diff --git a/tests/cases/Issue584.ts b/tests/cases/Issue584.ts new file mode 100644 index 00000000..b1233dad --- /dev/null +++ b/tests/cases/Issue584.ts @@ -0,0 +1,4 @@ +if (startDragXOffset < cornerDistanceThreshold > (shapeWidth - cornerDistanceThreshold)) { +} +if (startDragXOffset < cornerDistanceThreshold && startDragYOffset > (shapeWidth - cornerDistanceThreshold)) { +} \ No newline at end of file diff --git a/tests/cases/Issue585.tsx b/tests/cases/Issue585.tsx new file mode 100644 index 00000000..a6f88679 --- /dev/null +++ b/tests/cases/Issue585.tsx @@ -0,0 +1,4 @@ +// @onlyOwnGrammar - As this has jsx +const a =