Repository: microsoft/TypeScript-TmLanguage Branch: master Commit: eeeb0dc4daa8 Files: 962 Total size: 7.5 MB Directory structure: gitextract_wrlgz6ya/ ├── .gitattributes ├── .github/ │ ├── ISSUE_TEMPLATE/ │ │ └── bug_report.md │ └── workflows/ │ ├── CI.yml │ └── accept-baselines.yml ├── .gitignore ├── .vscode/ │ └── settings.json ├── Comments.tmPreferences ├── ErrorList.YAML-tmLanguage ├── FindRefs.YAML-tmLanguage ├── LICENSE.txt ├── README.md ├── SECURITY.md ├── ThirdPartyNotices.txt ├── TypeScript Indent.YAML-tmPreferences ├── TypeScript Indent.tmPreferences ├── TypeScript.YAML-tmLanguage ├── TypeScript.YAML-tmTheme ├── TypeScript.tmLanguage ├── TypeScript.tmTheme ├── TypeScriptReact.YAML-tmLanguage ├── TypeScriptReact.YAML-tmTheme ├── TypeScriptReact.tmLanguage ├── TypeScriptReact.tmTheme ├── build/ │ ├── build.ts │ ├── index.d.ts │ └── tsconfig.json ├── package.json └── tests/ ├── baselines/ │ ├── Abstracts.baseline.txt │ ├── ArrowFunctionInsideTypeAssertion.baseline.txt │ ├── AsConstSatisfies.baseline.txt │ ├── Comments.baseline.txt │ ├── FunctionMethodOverloads.baseline.txt │ ├── FunctionMethodParameters.baseline.txt │ ├── FunctionMethodReturnTypes.baseline.txt │ ├── Issue10.baseline.txt │ ├── Issue1006.baseline.txt │ ├── Issue11.baseline.txt │ ├── Issue110.baseline.txt │ ├── Issue112.baseline.txt │ ├── Issue114.baseline.txt │ ├── Issue115.baseline.txt │ ├── Issue119.baseline.txt │ ├── Issue124.baseline.txt │ ├── Issue131.baseline.txt │ ├── Issue133.baseline.txt │ ├── Issue135.baseline.txt │ ├── Issue139.baseline.txt │ ├── Issue142.baseline.txt │ ├── Issue143.baseline.txt │ ├── Issue146.baseline.txt │ ├── Issue148.baseline.txt │ ├── Issue149.baseline.txt │ ├── Issue152.baseline.txt │ ├── Issue153.baseline.txt │ ├── Issue154.baseline.txt │ ├── Issue155.baseline.txt │ ├── Issue156.baseline.txt │ ├── Issue157.baseline.txt │ ├── Issue158.baseline.txt │ ├── Issue161.baseline.txt │ ├── Issue163.baseline.txt │ ├── Issue166.baseline.txt │ ├── Issue171.baseline.txt │ ├── Issue172.baseline.txt │ ├── Issue175.baseline.txt │ ├── Issue177.baseline.txt │ ├── Issue178.baseline.txt │ ├── Issue180.baseline.txt │ ├── Issue182.baseline.txt │ ├── Issue183.baseline.txt │ ├── Issue186.baseline.txt │ ├── Issue187.baseline.txt │ ├── Issue191.baseline.txt │ ├── Issue193.baseline.txt │ ├── Issue197.baseline.txt │ ├── Issue198.baseline.txt │ ├── Issue200.baseline.txt │ ├── Issue202.baseline.txt │ ├── Issue203.baseline.txt │ ├── Issue206.baseline.txt │ ├── Issue208.baseline.txt │ ├── Issue212.baseline.txt │ ├── Issue215.baseline.txt │ ├── Issue216.baseline.txt │ ├── Issue217.baseline.txt │ ├── Issue218.baseline.txt │ ├── Issue219.baseline.txt │ ├── Issue22.baseline.txt │ ├── Issue221.baseline.txt │ ├── Issue223.baseline.txt │ ├── Issue226.baseline.txt │ ├── Issue230.baseline.txt │ ├── Issue232.baseline.txt │ ├── Issue235.baseline.txt │ ├── Issue236.baseline.txt │ ├── Issue237.baseline.txt │ ├── Issue239.baseline.txt │ ├── Issue241.baseline.txt │ ├── Issue243.baseline.txt │ ├── Issue244.baseline.txt │ ├── Issue247.baseline.txt │ ├── Issue248.baseline.txt │ ├── Issue249.baseline.txt │ ├── Issue250.baseline.txt │ ├── Issue251.baseline.txt │ ├── Issue252.baseline.txt │ ├── Issue262.baseline.txt │ ├── Issue264.baseline.txt │ ├── Issue276.baseline.txt │ ├── Issue28.baseline.txt │ ├── Issue280.baseline.txt │ ├── Issue283.baseline.txt │ ├── Issue285.baseline.txt │ ├── Issue288.baseline.txt │ ├── Issue292.baseline.txt │ ├── Issue294.baseline.txt │ ├── Issue3.baseline.txt │ ├── Issue304.baseline.txt │ ├── Issue305.baseline.txt │ ├── Issue307.baseline.txt │ ├── Issue314.baseline.txt │ ├── Issue318.baseline.txt │ ├── Issue32.baseline.txt │ ├── Issue321.baseline.txt │ ├── Issue322.baseline.txt │ ├── Issue326.baseline.txt │ ├── Issue334.baseline.txt │ ├── Issue335.baseline.txt │ ├── Issue337.baseline.txt │ ├── Issue338.baseline.txt │ ├── Issue339.baseline.txt │ ├── Issue343.baseline.txt │ ├── Issue344.baseline.txt │ ├── Issue346.baseline.txt │ ├── Issue347.baseline.txt │ ├── Issue351.baseline.txt │ ├── Issue356.baseline.txt │ ├── Issue357.baseline.txt │ ├── Issue359.baseline.txt │ ├── Issue36.baseline.txt │ ├── Issue361.baseline.txt │ ├── Issue365.baseline.txt │ ├── Issue366.baseline.txt │ ├── Issue368.baseline.txt │ ├── Issue37.baseline.txt │ ├── Issue375.baseline.txt │ ├── Issue376.baseline.txt │ ├── Issue377.baseline.txt │ ├── Issue379.baseline.txt │ ├── Issue380.baseline.txt │ ├── Issue381.baseline.txt │ ├── Issue382.baseline.txt │ ├── Issue383.baseline.txt │ ├── Issue384.baseline.txt │ ├── Issue387.baseline.txt │ ├── Issue388.baseline.txt │ ├── Issue389.baseline.txt │ ├── Issue391.baseline.txt │ ├── Issue393.baseline.txt │ ├── Issue394.baseline.txt │ ├── Issue396.baseline.txt │ ├── Issue397.baseline.txt │ ├── Issue398.baseline.txt │ ├── Issue402.baseline.txt │ ├── Issue403IncorrectlyDetectedArrowTypeParameters.baseline.txt │ ├── Issue403IncorrectlyDetectedFunctionCallAsArrow.baseline.txt │ ├── Issue405.baseline.txt │ ├── Issue407.baseline.txt │ ├── Issue408.baseline.txt │ ├── Issue415.baseline.txt │ ├── Issue417.baseline.txt │ ├── Issue418.baseline.txt │ ├── Issue42.baseline.txt │ ├── Issue420.baseline.txt │ ├── Issue421.baseline.txt │ ├── Issue423.baseline.txt │ ├── Issue427.baseline.txt │ ├── Issue428.baseline.txt │ ├── Issue43.baseline.txt │ ├── Issue430.baseline.txt │ ├── Issue431.baseline.txt │ ├── Issue433.baseline.txt │ ├── Issue434.baseline.txt │ ├── Issue435.baseline.txt │ ├── Issue44.baseline.txt │ ├── Issue441.baseline.txt │ ├── Issue444.baseline.txt │ ├── Issue445.baseline.txt │ ├── Issue450.baseline.txt │ ├── Issue452.baseline.txt │ ├── Issue453.baseline.txt │ ├── Issue455.baseline.txt │ ├── Issue458.baseline.txt │ ├── Issue460.baseline.txt │ ├── Issue461.baseline.txt │ ├── Issue463.baseline.txt │ ├── Issue466.baseline.txt │ ├── Issue468.baseline.txt │ ├── Issue470.baseline.txt │ ├── Issue471.baseline.txt │ ├── Issue472.baseline.txt │ ├── Issue476.baseline.txt │ ├── Issue477.baseline.txt │ ├── Issue478.baseline.txt │ ├── Issue480.baseline.txt │ ├── Issue482.baseline.txt │ ├── Issue484.baseline.txt │ ├── Issue485.baseline.txt │ ├── Issue486.baseline.txt │ ├── Issue491.baseline.txt │ ├── Issue496.baseline.txt │ ├── Issue499.baseline.txt │ ├── Issue5.baseline.txt │ ├── Issue500.baseline.txt │ ├── Issue502.baseline.txt │ ├── Issue506.baseline.txt │ ├── Issue510.baseline.txt │ ├── Issue513.baseline.txt │ ├── Issue515.baseline.txt │ ├── Issue518.baseline.txt │ ├── Issue521.baseline.txt │ ├── Issue522.baseline.txt │ ├── Issue525.baseline.txt │ ├── Issue526.baseline.txt │ ├── Issue530.baseline.txt │ ├── Issue531.baseline.txt │ ├── Issue536.baseline.txt │ ├── Issue538.baseline.txt │ ├── Issue540.baseline.txt │ ├── Issue543.baseline.txt │ ├── Issue549.baseline.txt │ ├── Issue550.baseline.txt │ ├── Issue551.baseline.txt │ ├── Issue554.baseline.txt │ ├── Issue556.baseline.txt │ ├── Issue558.baseline.txt │ ├── Issue559.baseline.txt │ ├── Issue562.baseline.txt │ ├── Issue566.baseline.txt │ ├── Issue567.baseline.txt │ ├── Issue569.baseline.txt │ ├── Issue571.baseline.txt │ ├── Issue572.baseline.txt │ ├── Issue572ForLoop.baseline.txt │ ├── Issue575.baseline.txt │ ├── Issue578.baseline.txt │ ├── Issue579.baseline.txt │ ├── Issue580.baseline.txt │ ├── Issue581.baseline.txt │ ├── Issue584.baseline.txt │ ├── Issue585.baseline.txt │ ├── Issue586.baseline.txt │ ├── Issue59.baseline.txt │ ├── Issue590.baseline.txt │ ├── Issue591.baseline.txt │ ├── Issue592.baseline.txt │ ├── Issue595.baseline.txt │ ├── Issue598.baseline.txt │ ├── Issue601.baseline.txt │ ├── Issue602.baseline.txt │ ├── Issue604.baseline.txt │ ├── Issue605.baseline.txt │ ├── Issue606.baseline.txt │ ├── Issue607.baseline.txt │ ├── Issue608.baseline.txt │ ├── Issue609.baseline.txt │ ├── Issue610.baseline.txt │ ├── Issue612.baseline.txt │ ├── Issue613.baseline.txt │ ├── Issue616.baseline.txt │ ├── Issue62.baseline.txt │ ├── Issue623.baseline.txt │ ├── Issue624.baseline.txt │ ├── Issue625.baseline.txt │ ├── Issue626.baseline.txt │ ├── Issue628.baseline.txt │ ├── Issue629.baseline.txt │ ├── Issue63.baseline.txt │ ├── Issue632.baseline.txt │ ├── Issue634.baseline.txt │ ├── Issue635.baseline.txt │ ├── Issue636.baseline.txt │ ├── Issue637.baseline.txt │ ├── Issue637a.baseline.txt │ ├── Issue637b.baseline.txt │ ├── Issue638.baseline.txt │ ├── Issue639.baseline.txt │ ├── Issue64.baseline.txt │ ├── Issue642.baseline.txt │ ├── Issue643.baseline.txt │ ├── Issue646.baseline.txt │ ├── Issue647.baseline.txt │ ├── Issue65.baseline.txt │ ├── Issue650.baseline.txt │ ├── Issue651.baseline.txt │ ├── Issue652.baseline.txt │ ├── Issue653.baseline.txt │ ├── Issue654.baseline.txt │ ├── Issue66.baseline.txt │ ├── Issue661.baseline.txt │ ├── Issue662.baseline.txt │ ├── Issue663.baseline.txt │ ├── Issue665.baseline.txt │ ├── Issue666.baseline.txt │ ├── Issue667.baseline.txt │ ├── Issue668.baseline.txt │ ├── Issue670.baseline.txt │ ├── Issue672.baseline.txt │ ├── Issue673.baseline.txt │ ├── Issue674.baseline.txt │ ├── Issue675.baseline.txt │ ├── Issue677.baseline.txt │ ├── Issue677arrow.baseline.txt │ ├── Issue683.baseline.txt │ ├── Issue684.baseline.txt │ ├── Issue685.baseline.txt │ ├── Issue686.baseline.txt │ ├── Issue687.baseline.txt │ ├── Issue688.baseline.txt │ ├── Issue689.baseline.txt │ ├── Issue692.baseline.txt │ ├── Issue695.baseline.txt │ ├── Issue698.baseline.txt │ ├── Issue701.baseline.txt │ ├── Issue702.baseline.txt │ ├── Issue711.baseline.txt │ ├── Issue715.baseline.txt │ ├── Issue717.baseline.txt │ ├── Issue720.baseline.txt │ ├── Issue721.baseline.txt │ ├── Issue724.baseline.txt │ ├── Issue727.baseline.txt │ ├── Issue728.baseline.txt │ ├── Issue730.baseline.txt │ ├── Issue732.baseline.txt │ ├── Issue737.baseline.txt │ ├── Issue741.baseline.txt │ ├── Issue743.baseline.txt │ ├── Issue744.baseline.txt │ ├── Issue748.baseline.txt │ ├── Issue750.baseline.txt │ ├── Issue751.baseline.txt │ ├── Issue754.baseline.txt │ ├── Issue756.baseline.txt │ ├── Issue760.baseline.txt │ ├── Issue762.baseline.txt │ ├── Issue763.baseline.txt │ ├── Issue766.baseline.txt │ ├── Issue77.baseline.txt │ ├── Issue774.baseline.txt │ ├── Issue780.baseline.txt │ ├── Issue782.baseline.txt │ ├── Issue785.baseline.txt │ ├── Issue786.baseline.txt │ ├── Issue787.baseline.txt │ ├── Issue790.baseline.txt │ ├── Issue791.baseline.txt │ ├── Issue793.baseline.txt │ ├── Issue794.baseline.txt │ ├── Issue796.baseline.txt │ ├── Issue797.baseline.txt │ ├── Issue811.baseline.txt │ ├── Issue816.baseline.txt │ ├── Issue82.baseline.txt │ ├── Issue822.baseline.txt │ ├── Issue823.baseline.txt │ ├── Issue832.baseline.txt │ ├── Issue836.baseline.txt │ ├── Issue840.baseline.txt │ ├── Issue841.baseline.txt │ ├── Issue844.baseline.txt │ ├── Issue846.baseline.txt │ ├── Issue850.baseline.txt │ ├── Issue858.baseline.txt │ ├── Issue868.baseline.txt │ ├── Issue87.baseline.txt │ ├── Issue870.baseline.txt │ ├── Issue88.baseline.txt │ ├── Issue89.baseline.txt │ ├── Issue90.baseline.txt │ ├── Issue921.baseline.txt │ ├── Issue923.baseline.txt │ ├── Issue924.baseline.txt │ ├── Issue96.baseline.txt │ ├── Issue964.baseline.txt │ ├── Issue975.baseline.txt │ ├── Issues573.baseline.txt │ ├── Issues597.baseline.txt │ ├── Issues648.baseline.txt │ ├── Issues649.baseline.txt │ ├── ParameterProperties.baseline.txt │ ├── SyntacticallyIncorrectStrings.baseline.txt │ ├── TsxSamples.baseline.txt │ ├── arbitraryModuleNamespaceIdentifiers.baseline.txt │ ├── arrow.baseline.txt │ ├── arrowInsideCall.baseline.txt │ ├── assertions.baseline.txt │ ├── autoAccessor.baseline.txt │ ├── awaitColoring.baseline.txt │ ├── awaitUsedInExpression.baseline.txt │ ├── awaitUsing.baseline.txt │ ├── awaited.baseline.txt │ ├── bigint.baseline.txt │ ├── binder.baseline.txt │ ├── conditionalTypes.baseline.txt │ ├── constType.baseline.txt │ ├── constTypeAssert.baseline.txt │ ├── constTypeParameter.baseline.txt │ ├── constants.baseline.txt │ ├── constructorType.baseline.txt │ ├── destructuringWithDefaults.baseline.txt │ ├── directives.baseline.txt │ ├── docComments.baseline.txt │ ├── enumMemberWithIntializer.baseline.txt │ ├── enumMemberWithQuotedMemberName.baseline.txt │ ├── exportDeclarations.baseline.txt │ ├── forof.baseline.txt │ ├── generator.baseline.txt │ ├── genericTaggedTemplate.baseline.txt │ ├── importAssert.baseline.txt │ ├── importTypeOnly.baseline.txt │ ├── importTypes.baseline.txt │ ├── inferTypes.baseline.txt │ ├── intrinsic.baseline.txt │ ├── issue1005.baseline.txt │ ├── issue327.baseline.txt │ ├── issue522_1.baseline.txt │ ├── issue534.baseline.txt │ ├── issue776.baseline.txt │ ├── issue806.baseline.txt │ ├── issue807.baseline.txt │ ├── issue807ts.baseline.txt │ ├── issue809.baseline.txt │ ├── issue812.baseline.txt │ ├── issue814.baseline.txt │ ├── issue824.baseline.txt │ ├── issue907.baseline.txt │ ├── issue909.baseline.txt │ ├── issue916.baseline.txt │ ├── issue927.baseline.txt │ ├── issue930.baseline.txt │ ├── issue932.baseline.txt │ ├── issue935.baseline.txt │ ├── issue940.baseline.txt │ ├── issue948.baseline.txt │ ├── issue949.baseline.txt │ ├── issue951.baseline.txt │ ├── issue957.baseline.txt │ ├── issue971.baseline.txt │ ├── javascript.baseline.txt │ ├── javascriptClasses.baseline.txt │ ├── jsdocProperty.baseline.txt │ ├── jsdocType.baseline.txt │ ├── jsxTagWithTypeArguments.baseline.txt │ ├── keyof.baseline.txt │ ├── mappedType.baseline.txt │ ├── modifierOperators.baseline.txt │ ├── multilineArrow.baseline.txt │ ├── multilineDestructuringParametersOfArrow.baseline.txt │ ├── multineTag.baseline.txt │ ├── multipleVariableDeclaration.baseline.txt │ ├── namedTuples.baseline.txt │ ├── namespaceAndModule.baseline.txt │ ├── notMultilineArrow1.baseline.txt │ ├── notMultilineArrow2.baseline.txt │ ├── notMultilineArrow3.baseline.txt │ ├── numeric.baseline.txt │ ├── numericAsType.baseline.txt │ ├── objectLiteral.baseline.txt │ ├── objectLiteralWithCast.baseline.txt │ ├── objectType.baseline.txt │ ├── optionalChaining.baseline.txt │ ├── parameterBindingPattern.baseline.txt │ ├── partialTypeArguments.baseline.txt │ ├── pr48_noSemiColon.baseline.txt │ ├── pr557_namespacedJsx.baseline.txt │ ├── privateFields.baseline.txt │ ├── property.baseline.txt │ ├── propertyNameInObjectBindingElement.baseline.txt │ ├── readonly.baseline.txt │ ├── readonlyModifier.baseline.txt │ ├── regexp.baseline.txt │ ├── resolutionMode.baseline.txt │ ├── restAndSpreadExpression.baseline.txt │ ├── restInBindingPattern.baseline.txt │ ├── satisfies.baseline.txt │ ├── specialNew.baseline.txt │ ├── templateLiteralType.baseline.txt │ ├── typeofClass.baseline.txt │ ├── typeparameterDefault.baseline.txt │ ├── using.baseline.txt │ ├── variableBindingPattern.baseline.txt │ └── varianceAnnotations.baseline.txt ├── build.ts ├── cases/ │ ├── Abstracts.ts │ ├── ArrowFunctionInsideTypeAssertion.ts │ ├── AsConstSatisfies.ts │ ├── Comments.ts │ ├── FunctionMethodOverloads.ts │ ├── FunctionMethodParameters.ts │ ├── FunctionMethodReturnTypes.ts │ ├── Issue10.ts │ ├── Issue1006.ts │ ├── Issue11.ts │ ├── Issue110.ts │ ├── Issue112.ts │ ├── Issue114.ts │ ├── Issue115.ts │ ├── Issue119.ts │ ├── Issue124.ts │ ├── Issue131.ts │ ├── Issue133.ts │ ├── Issue135.ts │ ├── Issue139.ts │ ├── Issue142.ts │ ├── Issue143.ts │ ├── Issue146.ts │ ├── Issue148.ts │ ├── Issue149.ts │ ├── Issue152.ts │ ├── Issue153.ts │ ├── Issue154.ts │ ├── Issue155.ts │ ├── Issue156.ts │ ├── Issue157.ts │ ├── Issue158.ts │ ├── Issue161.tsx │ ├── Issue163.ts │ ├── Issue166.ts │ ├── Issue171.ts │ ├── Issue172.ts │ ├── Issue175.ts │ ├── Issue177.ts │ ├── Issue178.ts │ ├── Issue180.ts │ ├── Issue182.ts │ ├── Issue183.ts │ ├── Issue186.ts │ ├── Issue187.ts │ ├── Issue191.ts │ ├── Issue193.ts │ ├── Issue197.ts │ ├── Issue198.ts │ ├── Issue200.ts │ ├── Issue202.tsx │ ├── Issue203.ts │ ├── Issue206.ts │ ├── Issue208.ts │ ├── Issue212.ts │ ├── Issue215.ts │ ├── Issue216.ts │ ├── Issue217.ts │ ├── Issue218.ts │ ├── Issue219.ts │ ├── Issue22.ts │ ├── Issue221.ts │ ├── Issue223.ts │ ├── Issue226.ts │ ├── Issue230.ts │ ├── Issue232.ts │ ├── Issue235.ts │ ├── Issue236.ts │ ├── Issue237.ts │ ├── Issue239.tsx │ ├── Issue241.ts │ ├── Issue243.ts │ ├── Issue244.ts │ ├── Issue247.tsx │ ├── Issue248.ts │ ├── Issue249.ts │ ├── Issue250.ts │ ├── Issue251.ts │ ├── Issue252.ts │ ├── Issue262.ts │ ├── Issue264.tsx │ ├── Issue276.ts │ ├── Issue28.ts │ ├── Issue280.tsx │ ├── Issue283.tsx │ ├── Issue285.ts │ ├── Issue288.ts │ ├── Issue292.ts │ ├── Issue294.ts │ ├── Issue3.ts │ ├── Issue304.ts │ ├── Issue305.ts │ ├── Issue307.ts │ ├── Issue314.ts │ ├── Issue318.ts │ ├── Issue32.ts │ ├── Issue321.ts │ ├── Issue322.ts │ ├── Issue326.ts │ ├── Issue334.ts │ ├── Issue335.ts │ ├── Issue337.ts │ ├── Issue338.ts │ ├── Issue339.ts │ ├── Issue343.ts │ ├── Issue344.tsx │ ├── Issue346.ts │ ├── Issue347.ts │ ├── Issue351.tsx │ ├── Issue356.ts │ ├── Issue357.tsx │ ├── Issue359.ts │ ├── Issue36.ts │ ├── Issue361.ts │ ├── Issue365.ts │ ├── Issue366.ts │ ├── Issue368.ts │ ├── Issue37.ts │ ├── Issue375.ts │ ├── Issue376.ts │ ├── Issue377.ts │ ├── Issue379.ts │ ├── Issue380.ts │ ├── Issue381.ts │ ├── Issue382.ts │ ├── Issue383.tsx │ ├── Issue384.ts │ ├── Issue387.ts │ ├── Issue388.ts │ ├── Issue389.ts │ ├── Issue391.ts │ ├── Issue393.ts │ ├── Issue394.ts │ ├── Issue396.ts │ ├── Issue397.ts │ ├── Issue398.ts │ ├── Issue402.ts │ ├── Issue403IncorrectlyDetectedArrowTypeParameters.ts │ ├── Issue403IncorrectlyDetectedFunctionCallAsArrow.ts │ ├── Issue405.ts │ ├── Issue407.ts │ ├── Issue408.ts │ ├── Issue415.tsx │ ├── Issue417.ts │ ├── Issue418.ts │ ├── Issue42.ts │ ├── Issue420.ts │ ├── Issue421.ts │ ├── Issue423.ts │ ├── Issue427.ts │ ├── Issue428.ts │ ├── Issue43.ts │ ├── Issue430.tsx │ ├── Issue431.ts │ ├── Issue433.ts │ ├── Issue434.ts │ ├── Issue435.ts │ ├── Issue44.ts │ ├── Issue441.ts │ ├── Issue444.ts │ ├── Issue445.ts │ ├── Issue450.ts │ ├── Issue452.ts │ ├── Issue453.ts │ ├── Issue455.ts │ ├── Issue458.ts │ ├── Issue460.ts │ ├── Issue461.tsx │ ├── Issue463.ts │ ├── Issue466.ts │ ├── Issue468.ts │ ├── Issue470.ts │ ├── Issue471.ts │ ├── Issue472.ts │ ├── Issue476.ts │ ├── Issue477.ts │ ├── Issue478.tsx │ ├── Issue480.ts │ ├── Issue482.ts │ ├── Issue484.ts │ ├── Issue485.ts │ ├── Issue486.ts │ ├── Issue491.ts │ ├── Issue496.ts │ ├── Issue499.ts │ ├── Issue5.ts │ ├── Issue500.ts │ ├── Issue502.ts │ ├── Issue506.ts │ ├── Issue510.ts │ ├── Issue513.ts │ ├── Issue515.ts │ ├── Issue518.tsx │ ├── Issue521.ts │ ├── Issue522.ts │ ├── Issue525.ts │ ├── Issue526.ts │ ├── Issue530.ts │ ├── Issue531.ts │ ├── Issue536.ts │ ├── Issue538.ts │ ├── Issue540.ts │ ├── Issue543.ts │ ├── Issue549.ts │ ├── Issue550.ts │ ├── Issue551.ts │ ├── Issue554.ts │ ├── Issue556.ts │ ├── Issue558.ts │ ├── Issue559.ts │ ├── Issue562.ts │ ├── Issue566.ts │ ├── Issue567.ts │ ├── Issue569.ts │ ├── Issue571.ts │ ├── Issue572.ts │ ├── Issue572ForLoop.ts │ ├── Issue575.ts │ ├── Issue578.ts │ ├── Issue579.ts │ ├── Issue580.ts │ ├── Issue581.ts │ ├── Issue584.ts │ ├── Issue585.tsx │ ├── Issue586.ts │ ├── Issue59.ts │ ├── Issue590.ts │ ├── Issue591.ts │ ├── Issue592.ts │ ├── Issue595.ts │ ├── Issue598.ts │ ├── Issue601.ts │ ├── Issue602.ts │ ├── Issue604.ts │ ├── Issue605.ts │ ├── Issue606.tsx │ ├── Issue607.ts │ ├── Issue608.ts │ ├── Issue609.ts │ ├── Issue610.ts │ ├── Issue612.ts │ ├── Issue613.ts │ ├── Issue616.ts │ ├── Issue62.ts │ ├── Issue623.ts │ ├── Issue624.tsx │ ├── Issue625.ts │ ├── Issue626.ts │ ├── Issue628.ts │ ├── Issue629.ts │ ├── Issue63.ts │ ├── Issue632.tsx │ ├── Issue634.ts │ ├── Issue635.ts │ ├── Issue636.tsx │ ├── Issue637.ts │ ├── Issue637a.ts │ ├── Issue637b.tsx │ ├── Issue638.ts │ ├── Issue639.ts │ ├── Issue64.ts │ ├── Issue642.ts │ ├── Issue643.ts │ ├── Issue646.ts │ ├── Issue647.ts │ ├── Issue65.ts │ ├── Issue650.ts │ ├── Issue651.ts │ ├── Issue652.ts │ ├── Issue653.ts │ ├── Issue654.ts │ ├── Issue66.tsx │ ├── Issue661.ts │ ├── Issue662.ts │ ├── Issue663.ts │ ├── Issue665.ts │ ├── Issue666.ts │ ├── Issue667.tsx │ ├── Issue668.ts │ ├── Issue670.ts │ ├── Issue672.ts │ ├── Issue673.ts │ ├── Issue674.ts │ ├── Issue675.ts │ ├── Issue677.ts │ ├── Issue677arrow.ts │ ├── Issue683.ts │ ├── Issue684.ts │ ├── Issue685.ts │ ├── Issue686.ts │ ├── Issue687.ts │ ├── Issue688.ts │ ├── Issue689.ts │ ├── Issue692.ts │ ├── Issue695.ts │ ├── Issue698.ts │ ├── Issue701.ts │ ├── Issue702.ts │ ├── Issue711.ts │ ├── Issue715.ts │ ├── Issue717.ts │ ├── Issue720.ts │ ├── Issue721.ts │ ├── Issue724.ts │ ├── Issue727.ts │ ├── Issue728.ts │ ├── Issue730.ts │ ├── Issue732.ts │ ├── Issue737.ts │ ├── Issue741.ts │ ├── Issue743.ts │ ├── Issue744.ts │ ├── Issue748.ts │ ├── Issue750.ts │ ├── Issue751.ts │ ├── Issue754.tsx │ ├── Issue756.ts │ ├── Issue760.ts │ ├── Issue762.ts │ ├── Issue763.ts │ ├── Issue766.ts │ ├── Issue77.ts │ ├── Issue774.ts │ ├── Issue780.ts │ ├── Issue782.ts │ ├── Issue785.ts │ ├── Issue786.ts │ ├── Issue787.ts │ ├── Issue790.ts │ ├── Issue791.ts │ ├── Issue793.ts │ ├── Issue794.tsx │ ├── Issue796.ts │ ├── Issue797.ts │ ├── Issue811.tsx │ ├── Issue816.ts │ ├── Issue82.ts │ ├── Issue822.ts │ ├── Issue823.ts │ ├── Issue832.ts │ ├── Issue836.ts │ ├── Issue840.ts │ ├── Issue841.ts │ ├── Issue844.ts │ ├── Issue846.ts │ ├── Issue850.ts │ ├── Issue858.ts │ ├── Issue868.ts │ ├── Issue87.ts │ ├── Issue870.ts │ ├── Issue88.tsx │ ├── Issue89.ts │ ├── Issue90.ts │ ├── Issue921.ts │ ├── Issue923.ts │ ├── Issue924.tsx │ ├── Issue96.ts │ ├── Issue964.ts │ ├── Issue975.ts │ ├── Issues573.ts │ ├── Issues597.ts │ ├── Issues648.tsx │ ├── Issues649.tsx │ ├── ParameterProperties.ts │ ├── SyntacticallyIncorrectStrings.ts │ ├── TsxSamples.tsx │ ├── arbitraryModuleNamespaceIdentifiers.ts │ ├── arrow.ts │ ├── arrowInsideCall.ts │ ├── assertions.ts │ ├── autoAccessor.ts │ ├── awaitColoring.ts │ ├── awaitUsedInExpression.ts │ ├── awaitUsing.ts │ ├── awaited.ts │ ├── bigint.ts │ ├── binder.ts │ ├── conditionalTypes.ts │ ├── constType.ts │ ├── constTypeAssert.ts │ ├── constTypeParameter.ts │ ├── constants.ts │ ├── constructorType.ts │ ├── destructuringWithDefaults.ts │ ├── directives.ts │ ├── docComments.ts │ ├── enumMemberWithIntializer.ts │ ├── enumMemberWithQuotedMemberName.ts │ ├── exportDeclarations.ts │ ├── forof.ts │ ├── generator.ts │ ├── genericTaggedTemplate.ts │ ├── importAssert.ts │ ├── importTypeOnly.ts │ ├── importTypes.ts │ ├── inferTypes.ts │ ├── intrinsic.ts │ ├── issue1005.ts │ ├── issue327.ts │ ├── issue522_1.ts │ ├── issue534.tsx │ ├── issue776.ts │ ├── issue806.ts │ ├── issue807.tsx │ ├── issue807ts.ts │ ├── issue809.ts │ ├── issue812.ts │ ├── issue814.ts │ ├── issue824.ts │ ├── issue907.ts │ ├── issue909.ts │ ├── issue916.ts │ ├── issue927.ts │ ├── issue930.ts │ ├── issue932.ts │ ├── issue935.ts │ ├── issue940.ts │ ├── issue948.ts │ ├── issue949.ts │ ├── issue951.ts │ ├── issue957.ts │ ├── issue971.ts │ ├── javascript.ts │ ├── javascriptClasses.ts │ ├── jsdocProperty.ts │ ├── jsdocType.ts │ ├── jsxTagWithTypeArguments.tsx │ ├── keyof.ts │ ├── mappedType.ts │ ├── modifierOperators.ts │ ├── multilineArrow.ts │ ├── multilineDestructuringParametersOfArrow.ts │ ├── multineTag.tsx │ ├── multipleVariableDeclaration.ts │ ├── namedTuples.ts │ ├── namespaceAndModule.ts │ ├── notMultilineArrow1.ts │ ├── notMultilineArrow2.ts │ ├── notMultilineArrow3.ts │ ├── numeric.ts │ ├── numericAsType.ts │ ├── objectLiteral.ts │ ├── objectLiteralWithCast.ts │ ├── objectType.ts │ ├── optionalChaining.ts │ ├── parameterBindingPattern.ts │ ├── partialTypeArguments.ts │ ├── pr48_noSemiColon.ts │ ├── pr557_namespacedJsx.tsx │ ├── privateFields.ts │ ├── property.ts │ ├── propertyNameInObjectBindingElement.ts │ ├── readonly.ts │ ├── readonlyModifier.ts │ ├── regexp.ts │ ├── resolutionMode.ts │ ├── restAndSpreadExpression.ts │ ├── restInBindingPattern.ts │ ├── satisfies.ts │ ├── specialNew.ts │ ├── templateLiteralType.ts │ ├── typeofClass.ts │ ├── typeparameterDefault.ts │ ├── using.ts │ ├── variableBindingPattern.ts │ └── varianceAnnotations.ts ├── test.ts └── tsconfig.json ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitattributes ================================================ # 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 ================================================ FILE: .github/ISSUE_TEMPLATE/bug_report.md ================================================ --- 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 ``` ================================================ FILE: .github/workflows/CI.yml ================================================ 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 ================================================ FILE: .github/workflows/accept-baselines.yml ================================================ 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 ================================================ FILE: .gitignore ================================================ node_modules build/*.js tests/*.js tests/generated/* xunit.xml *.tsbuildinfo ================================================ FILE: .vscode/settings.json ================================================ // Place your settings in this file to overwrite default and user settings. { "editor.insertSpaces": true, "files.associations": { "*.YAML-tmLanguage": "yaml", "*.YAML-tmPreferences": "yaml", "*.YAML-tmTheme": "yaml" } } ================================================ FILE: Comments.tmPreferences ================================================ name Comments scope source.ts, source.tsx settings shellVariables name TM_COMMENT_START value // name TM_COMMENT_START_2 value /* name TM_COMMENT_END_2 value */ uuid FF9A09B1-D1C3-4AF0-9A11-2EC300F03184 ================================================ FILE: ErrorList.YAML-tmLanguage ================================================ # [PackageDev] target_format: plist, ext: tmLanguage --- name: Error List scopeName: text.error-list uuid: 52410ea6-4de5-4b0e-9be7-12842e39a3a6 patterns: - include: '#error-count' - include: '#filename' - include: '#message' repository: filename: match: ^([^ ].*:)$ captures: '1': {name: entity.name.filename.error-list} error-count: match: (?<=\[)(\d+\s*errors)(?=\]) captures: '1': {name: keyword.other.error-list} message: begin: \( end: \n patterns: - include: '#location' location: match: (?<=\()(\d+),\s*(\d+)(?=\)) captures: '1': {name: constant.numeric.location.error-list} '2': {name: constant.numeric.location.error-list} ... ================================================ FILE: FindRefs.YAML-tmLanguage ================================================ # [PackageDev] target_format: plist, ext: hidden-tmLanguage name: Find Refs scopeName: text.find-refs uuid: de594c8b-2688-48c1-bc73-b5c935e408b8 patterns: - include: '#filename' - include: '#header' - include: '#footer' - include: '#reference' - include: '#line-with-match' repository: filename: match: ^([^ ].*:)$ captures: '1': {name: entity.name.filename.find-refs} footer: name: text.find-refs match: '^[0-9]+ matches in [0-9+] files\s*$' header: name: text.find-refs match: ^References to .*$ line-with-match: begin: '^ +([0-9]+):' end: $ beginCaptures: '1': {name: constant.numeric.line-number.match.find-refs } patterns: - include: '#single-line-ts' single-line-ts: name: meta.ts.find-refs patterns: - include: '#expression' # The remainder of this file is a copy of the TypeScript # grammar, but with end patterns augmented so that they # always stay within a single line (since this grammar # is for single-line referenes into TypeScript files) var-expr: name: meta.var.expr.ts begin: (?]|var|type|function|class|interface) patterns: - include: '#type' enum-declaration: name: meta.enum.declaration.ts match: (?:\b(const)\s+)?\b(enum)\s+([a-zA-Z_$][\w$]*) captures: '1': { name: storage.modifier.ts} '2': { name: storage.type.ts } '3': { name: entity.name.class.ts } object-declaration: name: meta.declaration.object.ts begin: '\b(?:(export)\s+)?\b(class|interface)\b(?:\s+([a-zA-Z_$][\w$]*))' beginCaptures: '1': { name: storage.modifier.ts } '2': { name: storage.type.ts } '3': { name: entity.name.class.ts } end: $|(?=\}) endCaptures: '1': { name: brace.curly.ts } patterns: - include: '#type-parameters' - include: '#object-heritage' - include: '#object-body' - include: '#comment' object-heritage: name: meta.object.heritage.ts match: (?:\b(extends|implements)\b|,)(?:\s+([a-zA-Z_$][.\w$]*)) captures: '1': { name: storage.modifier.ts } '2': { name: storage.type.ts } object-body: name: meta.object.body.ts begin: \{ end: $|(?=\}) patterns: - include: '#comment' - include: '#field-declaration' - include: '#method-declaration' - include: '#indexer-declaration' - include: '#type-annotation' - include: '#variable-initializer' - include: '#access-modifier' - include: '#static-modifier' - include: '#property-accessor' object-type: name: meta.object.type.ts begin: \{ end: $|\} patterns: - include: '#comment' - include: '#field-declaration' - include: '#method-declaration-no-body' - include: '#indexer-declaration' - include: '#type-annotation' field-declaration: name: meta.field.declaration.ts match: '\b([a-zA-Z_$][\w$]*)\s*(\?\s*)?(?=(=|:))' captures: '1': { name: variable.ts } '2': { name: keyword.operator.ts } method-declaration: name: meta.method.declaration.ts begin: '\b(?:(get|set)\s+)?\[?([a-zA-Z_$][\.\w$]*)\s*\]?\s*(\??)\s*(?=\()' beginCaptures: '1': { name: storage.type.property.ts } '2': { name: entity.name.function.ts } '3': { name: keyword.operator.ts } end: '$|\}|[;,]' patterns: - include: '#comment' - include: '#function-parameters' - include: '#type-annotation' - include: '#decl-block' method-declaration-no-body: name: meta.method.declaration.ts begin: '\b(?:(get|set)\s+)?\[?([a-zA-Z_$][\.\w$]*)\s*\]?\s*(\??)\s*(?=\()' beginCaptures: '1': { name: storage.type.property.ts } '2': { name: entity.name.function.ts } '3': { name: keyword.operator.ts } end: '$|(?=\})|[;,]' patterns: - include: '#comment' - include: '#function-parameters' - include: '#type-annotation' - include: '#decl-block' indexer-declaration: name: meta.indexer.declaration.ts begin: \[ end: \]\s*(\?\s*)?|$ endCaptures: '1': { name: keyword.operator.ts } patterns: - include: '#type-annotation' - include: '#indexer-parameter' - include: '#expression' indexer-parameter: name: meta.indexer.parameter.ts match: ([a-zA-Z_$][\w$]*)(?=\:) captures: '1': { name: variable.parameter.ts} function-declaration: name: meta.function.ts begin: \b(function)\b(?:\s+([a-zA-Z_$][\w$]*))?\s* beginCaptures: '1': { name: storage.type.function.ts } '2': { name: entity.name.function.ts } end: $|(?=\}|;) patterns: - include: '#comment' - include: '#type-parameters' - include: '#function-parameters' - include: '#return-type' - include: '#decl-block' block: name: meta.block.ts begin: \{ end: $|\} patterns: - include: '#expression' - include: '#object-member' decl-block: name: meta.decl.block.ts begin: \{ end: $|(?=\}) patterns: - include: '#expression' function-parameters: name: meta.function-parameters.ts begin: \( end: $|\) patterns: - include: '#comment' - include: '#parameter-name' - include: '#type-annotation' - include: '#variable-initializer' function-type-parameters: name: meta.function.type.ts begin: \( end: $|\) patterns: - include: '#comment' - include: '#parameter-name' - include: '#type-annotation' - include: '#variable-initializer' parameter-name: name: parameter.name.ts match: '(?:\s*\b(public|private)\b\s+)?(\.\.\.)?\s*([a-zA-Z_$][\w$]*)\s*(\??)' captures: '1': { name: storage.modifier.ts } '2': { name: keyword.operator.ts } '3': { name: variable.parameter.ts } '4': { name: keyword.operator.ts } return-type: name: meta.return.type.ts begin: '(?<=\)):' end: $|(?=\{|;|//) patterns: - include: '#type' type-annotation: name: meta.type.annotation.ts begin: ":" end: (?=[,);}\[\]])|(?==[^>])|(?<=[a-z]|>)\s*(?=\{|$|//) patterns: - include: '#type' - include: '#comment' type: name: meta.type.ts patterns: - include: '#type-name' - include: '#type-parameters' - include: '#type-union' - include: '#object-type' - include: '#function-type-parameters' - include: '#function-type-return-type' function-type-return-type: name: meta.function.type.return.ts begin: '=>' end: $|(?=[,\){]|//) patterns: - include: '#type' type-union: name: meta.type.union.ts begin: '(\|)' beginCaptures: '1': { name: keyword.operator.ts } end: '$|([a-zA-Z_$][.\w$]*)' endCaptures: '1': { name: storage.type.ts } patterns: - include: '#comment' type-name: name: storage.type.ts match: '[a-zA-Z_$][.\w$]*' type-parameters: name: meta.type.parameters.ts begin: '<' end: '$|(?=var|type|function|class|interface)|>' patterns: - name: keyword.other.ts match: '\b(extends)\b' - include: '#comment' - include: '#type' variable-initializer: begin: (=) beginCaptures: '1': { name: keyword.operator.ts } end: $|(?=[,);=]) patterns: - include: '#expression' expression: name: meta.expression.ts patterns: - include: '#string' - include: '#regex' - include: '#template' - include: '#comment' - include: '#literal' - include: '#paren-expression' - include: '#var-expr' - include: '#declaration' - include: '#cast' - include: '#new-expr' - include: '#block' - include: '#expression-operator' - include: '#relational-operator' - include: '#arithmetic-operator' - include: '#logic-operator' - include: '#assignment-operator' - include: '#storage-keyword' - include: '#control-statement' - include: '#switch-case' - include: '#for-in-simple' for-in-simple: name: forin.expr.ts match: (?<=\()\s*\b(var|let)\s+([a-zA-Z_$][\w$]*)\s+(in)\b captures: '1': { name: storage.type.ts } '3': { name: keyword.operator.ts } cast: name: cast.expr.ts match: '<\s*([a-zA-Z_$][.\w$]*)\s*(?:<([a-zA-Z_$][.\w$]*)>)?\s*(\[\])*\s*>' captures: '1': { name: storage.type.ts } '2': { name: storage.type.ts } new-expr: name: new.expr.ts match: '\b(new)\b\s*([a-zA-Z_$][.\w$]*)' captures: '1': { name: keyword.operator.ts } '2': { name: storage.type.ts } # TODO: object members with quoted or numric lhs object-member: name: meta.object.member.ts begin: '[a-zA-Z_$][\w$]*\s*:' end: $|(?=,|\}) patterns: - include: '#expression' expression-operator: name: keyword.operator.ts match: =>|\b(delete|export|import|in|instanceof|module|new|typeof|void)\b arithmetic-operator: name: keyword.operator.ts match: \*|/|\-\-|\-|\+\+|\+|% relational-operator: name: keyword.operator.ts match: ===|!==|==|!=|<=|>=|<>|=|<|> assignment-operator: name: keyword.operator.ts match: <<=|>>>=|>>=|\*=|(? ## 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). ================================================ FILE: ThirdPartyNotices.txt ================================================ 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 ================================================ FILE: TypeScript Indent.YAML-tmPreferences ================================================ # [PackageDev] target_format: plist, ext: tmPreferences --- name: TypeScript Indent uuid: 77966fa8-af34-4f1e-8535-e556d5063853 scope: source.ts, source.tsx settings: bracketIndentNextLinePattern: > (?x) ^ \s* \b(if|while|else)\b [^;]* $ | ^ \s* \b(for)\b .* $ decreaseIndentPattern: ^(.*\*/)?\s*\}.*$ increaseIndentPattern: ^.*\{[^}"']*$ ================================================ FILE: TypeScript Indent.tmPreferences ================================================ name TypeScript Indent scope source.ts, source.tsx settings bracketIndentNextLinePattern (?x) ^ \s* \b(if|while|else)\b [^;]* $ | ^ \s* \b(for)\b .* $ decreaseIndentPattern ^(.*\*/)?\s*\}.*$ increaseIndentPattern ^.*\{[^}"']*$ uuid 77966fa8-af34-4f1e-8535-e556d5063853 ================================================ FILE: TypeScript.YAML-tmLanguage ================================================ # [PackageDev] target_format: plist, ext: tmLanguage --- name: TypeScript 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: '#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: '{{startOfIdentifier}}(declare|export){{endOfIdentifier}}' control-statement: patterns: - include: '#switch-statement' - include: '#for-loop' - name: keyword.control.trycatch.ts match: '{{startOfIdentifier}}(catch|finally|throw|try){{endOfIdentifier}}' - match: '{{startOfIdentifier}}(break|continue|goto)\s+({{identifier}}){{endOfIdentifier}}' captures: '1': { name: keyword.control.loop.ts } '2': { name: entity.name.label.ts } - name: keyword.control.loop.ts match: '{{startOfIdentifier}}(break|continue|do|goto|while){{endOfIdentifier}}' - begin: '{{startOfIdentifier}}(return){{endOfIdentifier}}' beginCaptures: '0': { name: keyword.control.flow.ts } end: (?=[;}]|$|{{endOfStatement}}) patterns: - include: '#expression' - name: keyword.control.switch.ts match: '{{startOfIdentifier}}(case|default|switch){{endOfIdentifier}}' - include: '#if-statement' - name: keyword.control.conditional.ts match: '{{startOfIdentifier}}(else|if){{endOfIdentifier}}' - name: keyword.control.with.ts match: '{{startOfIdentifier}}(with){{endOfIdentifier}}' - name: keyword.control.ts match: '{{startOfIdentifier}}(package){{endOfIdentifier}}' - name: keyword.other.debugger.ts match: '{{startOfIdentifier}}(debugger){{endOfIdentifier}}' label: patterns: # handle declaration block followed by label so as to not confuse it with { followed by ternary operator which would be object literal - begin: '{{label}}(?=\s*\{)' beginCaptures: '1': { name: entity.name.label.ts } '2': { name: punctuation.separator.label.ts } end: (?<=\}) patterns: - include: '#decl-block' - match: '{{label}}' 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: '{{startOfIdentifier}}\@' beginCaptures: '0': { name: punctuation.decorator.ts } end: (?=\s) patterns: - include: '#expression' #variable, parameters, fields var-expr: patterns: # let/var - name: meta.var.expr.ts begin: (?={{varExprStart}}) end: (?!{{varExprStart}})((?=^|;|}|({{startOfIdentifier}}(of|in)\s+)|{{endOfStatement}})|((? - 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' 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: punctuation.definition.block.ts } end: \} endCaptures: '0': { name: punctuation.definition.block.ts } patterns: - include: '#comment' - 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: '#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: '{{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: 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: '#arrow-return-type-body' 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' #type parameters 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: '{{startOfIdentifier}}(extends|in|out|const){{endOfIdentifier}}' - include: '#type' - include: '#punctuation-comma' - name: keyword.operator.assignment.ts match: (=)(?!>) #type arguments 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: '{{startOfIdentifier}}(_){{endOfIdentifier}}' captures: '0': { name: keyword.operator.type.ts } - include: '#type' - include: '#punctuation-comma' #different types 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: '{{startOfIdentifier}}(readonly){{endOfIdentifier}}\s*' captures: '1': { name: storage.modifier.ts } - include: '#type-name' type-primitive: name: support.type.primitive.ts match: '{{startOfIdentifier}}(string|number|bigint|boolean|symbol|any|void|never|unknown){{endOfIdentifier}}' type-builtin-literals: name: support.type.builtin.ts match: '{{startOfIdentifier}}(this|true|false|undefined|null|object){{endOfIdentifier}}' 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: '{{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: '#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' #conditional type type-conditional: patterns: - 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' # 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: '0': { name: meta.brace.round.ts } end: \) endCaptures: '0': { name: meta.brace.round.ts } patterns: #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' type-function-return-type: patterns: # 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' #type operators type-operators: patterns: - 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: - 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: - 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: - begin: '({{identifier}})\s*{{propertyAccess}}\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: '({{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 } #strings and template strings 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: '({{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: - 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: 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: '({{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: punctuation.definition.template-expression.begin.ts } end: \} endCaptures: '0': { name: punctuation.definition.template-expression.end.ts } patterns: - include: '#type' contentName: meta.embedded.line.ts #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: \\. #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' ... ================================================ FILE: TypeScript.YAML-tmTheme ================================================ # 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 } ... ================================================ FILE: TypeScript.tmLanguage ================================================ 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 ================================================ FILE: TypeScript.tmTheme ================================================ 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 ================================================ FILE: TypeScriptReact.YAML-tmLanguage ================================================ # [PackageDev] target_format: plist, ext: tmLanguage # Similar to TypeScript.YAML-tmLanguage except: # - Remove type assertion (cast.expr.tsx) # - Add JSX expression (HTML-like expression). --- name: TypeScriptReact scopeName: source.tsx fileTypes: [tsx] uuid: 805375ec-d614-41f5-8993-5843fe63ea82 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: # Additions: # expression repository need to include jsx first followed by whaterver ts grammar says expressionWithoutIdentifiers: patterns: - include: '#jsx' # Overrides: # 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: '#jsx' # jsx syntax is taken from https://github.com/babel/babel-sublime jsx: patterns: - include: '#jsx-tag-without-attributes-in-expression' - include: '#jsx-tag-in-expression' #jsx tags jsx-tag-without-attributes-in-expression: begin: '{{jsxLookBehindInExpression}}(?={{jsxOpeningTagWithoutAttributes}})' end: (?!{{jsxOpeningTagWithoutAttributes}}) patterns: - include: '#jsx-tag-without-attributes' jsx-tag-without-attributes: name: meta.tag.without-attributes.tsx begin: '{{jsxOpeningTagWithoutAttributes}}' end: '{{jsxClosingTag}}' 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: # We need to differentiate between the relational '<' operator and the beginning of a tag using the surrounding context. begin: |- (?x) {{jsxLookBehindInExpression}} (?!<\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s+[^=>])|,)) # 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: (?=) 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* (?:({{jsxTagOrAtrributeIdentifier}})(:))? ([_$[: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+ ... ================================================ FILE: TypeScriptReact.YAML-tmTheme ================================================ # VS theme settings for TypeScriptReact # These only contains additions to existing TypeScript theme --- name: TypeScriptReact uuid: 8B704EF9-AF8E-402F-933C-1D46D8C49E58 settings: # Additions - 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 } ... ================================================ FILE: TypeScriptReact.tmLanguage ================================================ 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* (<) ([^>\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+ ================================================ FILE: TypeScriptReact.tmTheme ================================================ 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 ================================================ FILE: build/build.ts ================================================ 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(); ================================================ FILE: build/index.d.ts ================================================ 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[]; } ================================================ FILE: build/tsconfig.json ================================================ { "compilerOptions": { "lib": ["ES2023"], "target": "ES2023", "module": "nodenext", "strict": true, "skipLibCheck": true }, "exclude": [ "node_modules" ] } ================================================ FILE: package.json ================================================ { "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" } } ================================================ FILE: tests/baselines/Abstracts.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/ArrowFunctionInsideTypeAssertion.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/AsConstSatisfies.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Comments.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/FunctionMethodOverloads.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/FunctionMethodParameters.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/FunctionMethodReturnTypes.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue10.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue1006.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue11.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue110.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue112.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue114.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue115.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue119.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue124.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue131.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue133.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue135.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue139.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue142.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue143.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue146.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue148.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue149.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue152.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue153.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue154.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue155.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue156.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue157.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue158.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue161.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue163.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue166.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue171.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue172.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue175.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue177.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue178.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue180.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue182.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue183.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue186.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue187.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue191.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue193.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue197.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue198.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue200.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue202.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue203.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue206.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue208.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue212.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue215.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue216.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue217.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue218.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue219.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue22.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue221.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue223.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue226.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue230.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue232.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue235.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue236.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue237.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue239.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue241.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue243.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue244.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue247.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue248.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue249.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue250.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue251.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue252.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue262.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue264.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue276.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue28.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue280.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue283.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue285.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue288.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue292.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue294.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue3.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue304.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue305.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue307.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue314.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue318.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue32.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue321.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue322.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue326.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue334.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue335.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue337.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue338.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue339.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue343.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue344.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue346.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue347.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue351.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue356.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue357.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue359.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue36.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue361.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue365.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue366.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue368.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue37.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue375.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue376.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue377.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue379.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue380.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue381.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue382.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue383.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue384.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue387.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue388.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue389.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue391.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue393.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue394.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue396.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue397.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue398.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue402.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue403IncorrectlyDetectedArrowTypeParameters.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue403IncorrectlyDetectedFunctionCallAsArrow.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue405.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue407.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue408.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue415.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue417.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue418.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue42.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue420.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue421.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue423.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue427.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue428.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue43.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue430.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue431.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue433.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue434.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue435.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue44.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue441.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue444.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue445.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue450.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue452.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue453.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue455.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue458.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue460.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue461.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue463.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue466.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue468.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue470.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue471.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue472.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue476.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue477.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue478.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue480.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue482.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue484.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue485.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue486.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue491.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue496.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue499.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue5.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue500.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue502.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue506.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue510.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue513.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue515.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue518.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue521.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue522.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue525.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue526.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue530.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue531.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue536.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue538.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue540.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue543.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue549.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue550.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue551.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue554.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue556.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue558.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue559.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue562.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue566.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue567.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue569.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue571.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue572.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue572ForLoop.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue575.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue578.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue579.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue580.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue581.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue584.baseline.txt ================================================ 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 ================================================ FILE: tests/baselines/Issue585.baseline.txt ================================================ original file ----------------------------------- // @onlyOwnGrammar - As this has jsx const a = `, directives: [CountClicks] }) export class AppComponent { constructor() { console.clear(); } } ================================================ FILE: tests/cases/Issue146.ts ================================================ function foo() { return 'bar'; } function* foo() { yield 'bar'; yield* ['bar']; } ================================================ FILE: tests/cases/Issue148.ts ================================================ class Test { constructor( @inject private test: string, @inject("test") private test2: string, @inject("test") test3: string, public test4: string ) { } } ================================================ FILE: tests/cases/Issue149.ts ================================================ 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 ""; } ================================================ FILE: tests/cases/Issue152.ts ================================================ var node; for(var i; i< 45;i++) { node = 234; node.a = 122; node.b += 122; node.b += '1'+1+'2'; } ================================================ FILE: tests/cases/Issue153.ts ================================================ 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); } } } ================================================ FILE: tests/cases/Issue154.ts ================================================ class TestCase { ['foo']() { this.registerComponent('foo-bar'); } } class TestCase2 { foo() { this.registerComponent('foo-bar'); } } ================================================ FILE: tests/cases/Issue155.ts ================================================ matchQuery.find().then(function (results) { for (i=0;i([ 'foo', 'bar' ]); items.delete('foo'); ================================================ FILE: tests/cases/Issue158.ts ================================================ class Test { public constructor() { for (let it=0; it<10; it++) { } } private doSomething() { } } ================================================ FILE: tests/cases/Issue161.tsx ================================================ // @onlyOwnGrammar - As this has jsx let root: React.ReactElement<{}>; let page: PageName; if (isViaPage) { root = ; page = 'via'; } ================================================ FILE: tests/cases/Issue163.ts ================================================ const o = { async f() { } }; ================================================ FILE: tests/cases/Issue166.ts ================================================ 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 ================================================ FILE: tests/cases/Issue171.ts ================================================ 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" }); } ================================================ FILE: tests/cases/Issue172.ts ================================================ let f = async (x) => {}; let f2 = async function(x) {}; ================================================ FILE: tests/cases/Issue175.ts ================================================ var $ = ''; var $foo = ''; ================================================ FILE: tests/cases/Issue177.ts ================================================ () => (/s/); () => /s/; ================================================ FILE: tests/cases/Issue178.ts ================================================ const a: { [key: string]: () => string } = null; const b: { [key: string]: [string, () => string] } = null; const c = "foobar"; const d = 5; const e: any = null; ================================================ FILE: tests/cases/Issue180.ts ================================================ 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"; } } ================================================ FILE: tests/cases/Issue186.ts ================================================ 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; } ================================================ FILE: tests/cases/Issue187.ts ================================================ const trim = module.exports = str => trim.trailing(trim.leading(str)); const trim = module.exports = function(str) { return trim.trailing(trim.leading(str)); } ================================================ FILE: tests/cases/Issue191.ts ================================================ 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:`); }) }; } ================================================ FILE: tests/cases/Issue193.ts ================================================ function Main_Функция(s: string) { } function Функция_Main(s: string) { } let item = "value1"; let элемент = "value2"; ================================================ FILE: tests/cases/Issue197.ts ================================================ 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"; } ================================================ FILE: tests/cases/Issue198.ts ================================================ 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; ================================================ FILE: tests/cases/Issue200.ts ================================================ declare module 'goog:goog.i18n.NumberFormatSymbols_en_TT' { import alias = lool.clutz.goog.i18n.NumberFormatSymbols_en_TT; export default alias; } ================================================ FILE: tests/cases/Issue202.tsx ================================================ interface Test { test: T; } interface Props { prop: Test; } class Whatever { } ================================================ FILE: tests/cases/Issue203.ts ================================================ var [] = 'fafa'.replace('blah'); console.log('hello'); var [] = 'fafa'.replace(''); console.log('hello'); while { while() {} } ================================================ FILE: tests/cases/Issue206.ts ================================================ 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 ================================================ FILE: tests/cases/Issue208.ts ================================================ 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'); } ================================================ FILE: tests/cases/Issue212.ts ================================================ 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) ================================================ FILE: tests/cases/Issue215.ts ================================================ 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!"); } } ================================================ FILE: tests/cases/Issue217.ts ================================================ export class StatusSelector { @Output() select = new EventEmitter() statuses = ["started", "completed"] } export class StatusSelector2 { @Output() select = new EventEmitter(); statuses = ["started", "completed"] } ================================================ FILE: tests/cases/Issue218.ts ================================================ class A { foo(a, b) { } [foo](a, b) { } } ================================================ FILE: tests/cases/Issue219.ts ================================================ const { map, coordinate } = this.props if (!map) return; var marker; ================================================ FILE: tests/cases/Issue22.ts ================================================ app.get('/test/', (req, res) => { }); ================================================ FILE: tests/cases/Issue221.ts ================================================ class syntaxHighlightBug { variable = {"example":1}; public wronglyHighlitedCode() { var a = 1; return; } } ================================================ FILE: tests/cases/Issue223.ts ================================================ for (i = 0; i { } ================================================ FILE: tests/cases/Issue230.ts ================================================ // 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"); })); ================================================ FILE: tests/cases/Issue232.ts ================================================ for( let [k, component] of this.components){ let bounds = component.view.getBounds(); /// <= not highlighted, nor anything after this } ================================================ FILE: tests/cases/Issue235.ts ================================================ class A { @Route.GET('/*') get(q: Request, s: Response): void { s.sendFile(); } } ================================================ FILE: tests/cases/Issue236.ts ================================================ class Test { public before() { // ... } public [Symbol.iterator]() { // ... } public after() { // ... } } ================================================ FILE: tests/cases/Issue237.ts ================================================ export type Test = string // wrong comment color // should be this ================================================ FILE: tests/cases/Issue239.tsx ================================================ // @onlyOwnGrammar - As this has jsx const test = (true) ?

Broken Color

:

Also Broken Color

================================================ FILE: tests/cases/Issue241.ts ================================================ 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; } ================================================ FILE: tests/cases/Issue243.ts ================================================ '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; } } ================================================ FILE: tests/cases/Issue244.ts ================================================ a.withLatestFrom(axis === 'x' ? initialX : initialY) .map(x => undefined) .switch() .publish().refCount(); const targetX = targetSideObs('x'); const targetY = targetSideObs('y'); ================================================ FILE: tests/cases/Issue247.tsx ================================================ @dec<{}>() class Test { } ================================================ FILE: tests/cases/Issue248.ts ================================================ 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]; } } ================================================ FILE: tests/cases/Issue249.ts ================================================ const selectDictionary = (dictionaries: StoredDictionaries, lang:string) => { } function selectDictionary(dictionaries: StoredDictionaries, lang:string) { } ================================================ FILE: tests/cases/Issue250.ts ================================================ /** 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; } (); } ================================================ FILE: tests/cases/Issue251.ts ================================================ for(var j=0; (j
================================================ FILE: tests/cases/Issue276.ts ================================================ /** * @param {string} value * @param {string[]} arrayValue * @param {string} [optionalValue] */ function test(value: string, arrayValue: string[], optionalValue?: string) { } ================================================ FILE: tests/cases/Issue28.ts ================================================ /* Testing octals */ var x = 123; var y = 0x123; var z = 0b10101; var z = 0B00000; var j = 0o474774; var w = 0O767; ================================================ FILE: tests/cases/Issue280.tsx ================================================ // @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; }) }
; } } ================================================ FILE: tests/cases/Issue283.tsx ================================================ // @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.
; } } ================================================ FILE: tests/cases/Issue285.ts ================================================ let model = { links: { new: "sample" }, }; ================================================ FILE: tests/cases/Issue288.ts ================================================ // 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; ================================================ FILE: tests/cases/Issue292.ts ================================================ const shellOptions: IOptions = { filesToOpen, filesToCreate, filesToDiff }; const a = { filesToOpen: filesToOpen, filesToCreate: filesToCreate, filesToDiff: filesToDiff } ================================================ FILE: tests/cases/Issue294.ts ================================================ switch (0) { case 0: { const zero = 0; return zero; } } ================================================ FILE: tests/cases/Issue3.ts ================================================ let regex = /**/ /foo/; ================================================ FILE: tests/cases/Issue304.ts ================================================ export const EditorPanel = connect( (state: Immutable): Object => ( { edditorState: (state.editors[state.activeTab]), macroSettingsOpen: state.macroSettingsOpen, }), (dispatch: Dispatch): Object => ({ onchange(next: EditorSDtate): void { dispatch(actions) } }) ) ================================================ FILE: tests/cases/Issue305.ts ================================================ abstract class Base { protected abstract topic: string constructor(protected wire: Transport, protected token?: string, readonly bar?: boolean) { } } ================================================ FILE: tests/cases/Issue307.ts ================================================ class Test { method() { const obj = { a: 'hello' }; const { a } = obj; const x = 'world'; } } ================================================ FILE: tests/cases/Issue314.ts ================================================ let x = a ? b as X : c; let y = 123; ================================================ FILE: tests/cases/Issue318.ts ================================================ 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); } ); ================================================ FILE: tests/cases/Issue32.ts ================================================ /* 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 */ ================================================ FILE: tests/cases/Issue321.ts ================================================ 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; } } ================================================ FILE: tests/cases/Issue322.ts ================================================ 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 } ================================================ FILE: tests/cases/Issue326.ts ================================================ class Bar extends getFoo("baz") {} ================================================ FILE: tests/cases/Issue334.ts ================================================ 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; ================================================ FILE: tests/cases/Issue335.ts ================================================ 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() { } } ================================================ FILE: tests/cases/Issue337.ts ================================================ #!/usr/bin/env node -r babel-register ================================================ FILE: tests/cases/Issue338.ts ================================================ let a = { [['a', 'b', 'c'].join(' ')]: 'foo', }; ================================================ FILE: tests/cases/Issue339.ts ================================================ 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; }; } ================================================ FILE: tests/cases/Issue343.ts ================================================ console.log(`${Math.round(responseTime / requests)} ns (${Math.round(requests / ( responseTime / 1e9))}/sec)`); ================================================ FILE: tests/cases/Issue344.tsx ================================================ let a = Array(); // Highlight ok here interface egGenericsInArray { a: Array; } let s = "nothing should fail here..."; ================================================ FILE: tests/cases/Issue346.ts ================================================ 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) } ================================================ FILE: tests/cases/Issue347.ts ================================================ const a = new Promise (resolve => { const file = this.props.doc.file; resolve({ abc: Math.random() }); class Foo extends React.Component { render() { } } }); ================================================ FILE: tests/cases/Issue351.tsx ================================================ this._blockRenderMap = Map({}); this._eventsMap = {}; ================================================ FILE: tests/cases/Issue356.ts ================================================ 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; ================================================ FILE: tests/cases/Issue357.tsx ================================================ // @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}`}
} ) } ================================================ FILE: tests/cases/Issue359.ts ================================================ const test = (value: string) => { const a = 123; const b = { [`${value}[]`]: a, }; const c = 123; return b; } ================================================ FILE: tests/cases/Issue36.ts ================================================ let x = { hello() { let hello = "world"; } }; ================================================ FILE: tests/cases/Issue361.ts ================================================ const constructor = someObject.prototype.constructor; const objectLiteral = { constructor }; ================================================ FILE: tests/cases/Issue365.ts ================================================ class Renamer { constructor (private readonly srcName: string, private readonly target: string, readonly copy: boolean = false) {} } ================================================ FILE: tests/cases/Issue366.ts ================================================ let foo = a ? b ? c : d : e; let bar; ================================================ FILE: tests/cases/Issue368.ts ================================================ let creditCard = 'cc'; const CREDIT_CARD = 'CC'; console.log(`Payment Type: ${creditCard}`); console.log(`Payment Type: ${CREDIT_CARD}`); ================================================ FILE: tests/cases/Issue37.ts ================================================ //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 */ ================================================ FILE: tests/cases/Issue375.ts ================================================ // @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' }); ================================================ FILE: tests/cases/Issue376.ts ================================================ 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 ! } } ================================================ FILE: tests/cases/Issue377.ts ================================================ dt = ((dt[0] * 1e9 + dt[1]) / 1e6).toFixed(3).replace(/\.?0+$/, '') + 'ms'; ================================================ FILE: tests/cases/Issue379.ts ================================================ interface A { prop1: string prop2: string method1(): void prop3: string prop4: string } ================================================ FILE: tests/cases/Issue380.ts ================================================ let namespace; namespace = `${"a"}`; let x = 1 ================================================ FILE: tests/cases/Issue381.ts ================================================ class Foo{ constructor(){ } test(){ return `/game.php?village=${source}&screen=main&ajaxaction=upgrade_building&type=main&h=${csrf_token}&&client_time=${+new Date}` } noColorSyntax(){ } } ================================================ FILE: tests/cases/Issue382.ts ================================================ 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>(); } ================================================ FILE: tests/cases/Issue383.tsx ================================================ // @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) => (
); ================================================ FILE: tests/cases/Issue384.ts ================================================ declare function foo(): any declare function foo(): any export function X(): void export as namespace Y ================================================ FILE: tests/cases/Issue387.ts ================================================ // // 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 ); }); }); } // -------------------------------------------------------------------------------- ================================================ FILE: tests/cases/Issue388.ts ================================================ export const fun = (param: ParamType): FunResult => { } export const fun = (param: ParamType): FunResult => { } ================================================ FILE: tests/cases/Issue389.ts ================================================ [function () { let foo; }]; ================================================ FILE: tests/cases/Issue391.ts ================================================ 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; ================================================ FILE: tests/cases/Issue393.ts ================================================ class ColorsBars extends React.Component { constructor(...args) { super(...args) this.toggleEdit = this.toggleEdit.bind(this) } } ================================================ FILE: tests/cases/Issue394.ts ================================================ gulp.add('watch-' + (asset.name || asset.route), function () { gulp.watch('./modules/*' + asset.moduleRelativePath, ['build-' + (asset.name || asset.route)]); }); ================================================ FILE: tests/cases/Issue396.ts ================================================ /* 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() }); }); ================================================ FILE: tests/cases/Issue397.ts ================================================ const a = Math.max(...x); const b = 2; ================================================ FILE: tests/cases/Issue398.ts ================================================ let x: Array<{ name: string, fn(): any, field: string }> ================================================ FILE: tests/cases/Issue402.ts ================================================ 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 } }) ================================================ FILE: tests/cases/Issue403IncorrectlyDetectedArrowTypeParameters.ts ================================================ 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)) } }) ================================================ FILE: tests/cases/Issue403IncorrectlyDetectedFunctionCallAsArrow.ts ================================================ 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) } ================================================ FILE: tests/cases/Issue405.ts ================================================ function myFunction1 (a: string) { var r = true; return true } function myFunction2 (a: string): boolean { var r = true; return true } ================================================ FILE: tests/cases/Issue407.ts ================================================ let x: Map; let Y: Map; ================================================ FILE: tests/cases/Issue408.ts ================================================ assert(truthyValue, 'must be true'); path(pathArgs); ================================================ FILE: tests/cases/Issue415.tsx ================================================ // @onlyOwnGrammar - As this has jsx (); (); (); (); (); (); (bold); ================================================ FILE: tests/cases/Issue417.ts ================================================ const a = { 1: '1', '2': '2', } ================================================ FILE: tests/cases/Issue418.ts ================================================ 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))) } ================================================ FILE: tests/cases/Issue42.ts ================================================ return this.travelWorld((cell: Cell) => { cell.live = Math.random() < this.initialLifeProbability; return cell; }); ================================================ FILE: tests/cases/Issue420.ts ================================================ verify.quickInfos({ 1: "this: ContextualInterface", 2: "(parameter) this: void" }); ================================================ FILE: tests/cases/Issue421.ts ================================================ function f( arg: 'x' | 'y', arg2: 1 | 2) {} ================================================ FILE: tests/cases/Issue423.ts ================================================ interface Foo { bar: string; } type T = Foo; // line 5 interface Bar { foo: Foo; // line 7 } ================================================ FILE: tests/cases/Issue427.ts ================================================ function a(): { [key: string]: number } | { [key: string]: number } { throw 1 } function b(a: { [key: string]: number } | { [key: string]: number }): void { } ================================================ FILE: tests/cases/Issue428.ts ================================================ export function funct (a: number): string export function funct (a: number): number // this is implementation export function funct (a: number): any { } ================================================ FILE: tests/cases/Issue43.ts ================================================ var $this = $(this); $this.addClass("hehe"); ================================================ FILE: tests/cases/Issue430.tsx ================================================ // @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}

)) } } ================================================ FILE: tests/cases/Issue431.ts ================================================ myFunc (...argName) function otherFunc() {} // <-- Not highlighted. ================================================ FILE: tests/cases/Issue433.ts ================================================ declare module ILogin{ export interface Z {} } ================================================ FILE: tests/cases/Issue434.ts ================================================ 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; } ================================================ FILE: tests/cases/Issue435.ts ================================================ /** * 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. */ ================================================ FILE: tests/cases/Issue44.ts ================================================ interface TestInterface { testvar: string; testfunc(): string; } /* Testing Comments */ ================================================ FILE: tests/cases/Issue441.ts ================================================ func(1) async(1) ================================================ FILE: tests/cases/Issue444.ts ================================================ 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; } ================================================ FILE: tests/cases/Issue445.ts ================================================ /** * 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 } ================================================ FILE: tests/cases/Issue450.ts ================================================ // @onlyOwnGrammar - As this has type assertion let a = true ? 1 : 2; ================================================ FILE: tests/cases/Issue452.ts ================================================ class Test{} class Favorite extends Test< string | number, undefined > { // class content } ================================================ FILE: tests/cases/Issue453.ts ================================================ type Resolve = () => number; class Test { first(values: Map): number { return values.has('a') ? values.get('a')!() : 0; } second(): string { return 'foo'; } } ================================================ FILE: tests/cases/Issue455.ts ================================================ func(function () // } { if (false) return 1 else return 2 }); ================================================ FILE: tests/cases/Issue458.ts ================================================ export class Blah { get () {} } const x = { get () {} } ================================================ FILE: tests/cases/Issue460.ts ================================================ // single-line comment /* multi-line comment */ ================================================ FILE: tests/cases/Issue461.tsx ================================================ // @onlyOwnGrammar - As this has jsx class Foo { renderProgress = () => x render () { return (
{!this.state.loaded && this.renderProgress()}
) } } ================================================ FILE: tests/cases/Issue463.ts ================================================ const x = 1 if (x) return x ================================================ FILE: tests/cases/Issue466.ts ================================================ function foo(this: number, x: number) { } ================================================ FILE: tests/cases/Issue468.ts ================================================ ({ 'foo\'': 'bar' }) ================================================ FILE: tests/cases/Issue470.ts ================================================ var x = await import("./file1"); ================================================ FILE: tests/cases/Issue471.ts ================================================ const foo = true || `${'hello'}.txt` function syntaxHighlightingIsBroken() { } ================================================ FILE: tests/cases/Issue472.ts ================================================ interface I { bar1: { quantity: string }, bar2: { quantity: string } } ================================================ FILE: tests/cases/Issue476.ts ================================================ class Bug { static asdf(o, o2) { Bug.asdf("", '`') return { [ "a" ]: [ Bug.asdf("", '`') ] }; } } ================================================ FILE: tests/cases/Issue477.ts ================================================ 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 *() {} } ================================================ FILE: tests/cases/Issue478.tsx ================================================ // 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); } ================================================ FILE: tests/cases/Issue480.ts ================================================ /* @internal */ export interface Pattern { prefix: string; suffix: string; } // @internal export interface Pattern2 { prefix: string; suffix: string; } ================================================ FILE: tests/cases/Issue482.ts ================================================ let a = 1; let b = [new Object] let c = 1 ================================================ FILE: tests/cases/Issue484.ts ================================================ declare module 'foo'; declare module 'bar'; declare module 'baz'; interface Foo { bar: string; } ================================================ FILE: tests/cases/Issue485.ts ================================================ import a from 'a' // test import b from 'b' ================================================ FILE: tests/cases/Issue486.ts ================================================ const C = class { private data = 0; } ================================================ FILE: tests/cases/Issue491.ts ================================================ 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 ================================================ FILE: tests/cases/Issue496.ts ================================================ // @onlyOwnGrammar - As this has cast expression var x = 0; var y = 1; var z = x + y; ================================================ FILE: tests/cases/Issue499.ts ================================================ const fn = ({ arg = [], }) => { return "This line should be highlighted correctly"; } ================================================ FILE: tests/cases/Issue5.ts ================================================ 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" ================================================ FILE: tests/cases/Issue500.ts ================================================ 0 as any as string; ================================================ FILE: tests/cases/Issue502.ts ================================================ class Foo { bar () { [...this.foobar()]; [... this.foobar()]; } } ================================================ FILE: tests/cases/Issue506.ts ================================================ 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); }); } }); } ================================================ FILE: tests/cases/Issue510.ts ================================================ // 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 }); ================================================ FILE: tests/cases/Issue513.ts ================================================ (/a/u); ================================================ FILE: tests/cases/Issue515.ts ================================================ /** * @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. */ ================================================ FILE: tests/cases/Issue518.tsx ================================================ // @onlyOwnGrammar - As this has jsx (= 2 && i < 3 ? "first branch" : i > (j - 2) * 4 ? "second branch" : "third branch" } />) ================================================ FILE: tests/cases/Issue521.ts ================================================ const names = results.f(result.success ? (2) : 2).f(c => c.name) const a = 1; ================================================ FILE: tests/cases/Issue522.ts ================================================ 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(); ================================================ FILE: tests/cases/Issue525.ts ================================================ map(result.success ? (a) : 1).map(c => c.name) const a = 1; ================================================ FILE: tests/cases/Issue526.ts ================================================ if (a++ < b) { } export class A extends B { } ================================================ FILE: tests/cases/Issue530.ts ================================================ function getStats() { const query = query<[number], number>(` SELECT * FROM statistics WHERE unit_id = $1`) return database.execute(query, [id]) } ================================================ FILE: tests/cases/Issue531.ts ================================================ class Test { } export { Test as default }; ================================================ FILE: tests/cases/Issue536.ts ================================================ const z = (() => {})() ================================================ FILE: tests/cases/Issue538.ts ================================================ declare function f(): void; const x = f<"a", "b">(); ================================================ FILE: tests/cases/Issue540.ts ================================================ // 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 } ================================================ FILE: tests/cases/Issue543.ts ================================================ // @onlyOwnGrammar - As this has cast let x = -5; x = --x; x = +x; 1 && 2 & 3 | 4 + 5 ^ 6 && (5) ================================================ FILE: tests/cases/Issue549.ts ================================================ function foo(x, y){ if(x < y || (x > (y))){ } return 'of the jedi'; } ================================================ FILE: tests/cases/Issue550.ts ================================================ export const foo = (firstVariable: string, secondVariable: number): string => { return "foo" } export const bar = ( firstVariable: string, secondVariable: number, thirdVariable: string ): string => { return "baz" } ================================================ FILE: tests/cases/Issue551.ts ================================================ class a extends b, c { } class a2 extends b, c { } ================================================ FILE: tests/cases/Issue554.ts ================================================ async function f(x: Promise) { return { ...await x }; } ...new Object() ...function f() {} ...typeof x ...void x ...undefined ================================================ FILE: tests/cases/Issue556.ts ================================================ class Thing { foo: SomeFunc = () => void 0; bar = () => void 0; } ================================================ FILE: tests/cases/Issue558.ts ================================================ 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; }; ================================================ FILE: tests/cases/Issue559.ts ================================================ 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); ================================================ FILE: tests/cases/Issue562.ts ================================================ // @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; }); ================================================ FILE: tests/cases/Issue566.ts ================================================ 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; ================================================ FILE: tests/cases/Issue567.ts ================================================ 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} ================================================ FILE: tests/cases/Issue569.ts ================================================ export { default as x } export { x as default } ================================================ FILE: tests/cases/Issue571.ts ================================================ const o = { ["a" + "b"]() { return 0; // no highlighting! }, 'a\ '() { return 0; // no highlighting! } }; ================================================ FILE: tests/cases/Issue572.ts ================================================ function /*like here*/ * foo() { yield /*or here*/* [42]; } ================================================ FILE: tests/cases/Issue572ForLoop.ts ================================================ /*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*/ {} ================================================ FILE: tests/cases/Issue575.ts ================================================ function runQuery() { const query = createQuery<[number[]], Table>(` some SQL here `) return database.execute(query) } ================================================ FILE: tests/cases/Issue578.ts ================================================ if (targetAttribute) { if (!(targetAttribute instanceof Attribute)) { targetAttribute = new Attribute(targetAttribute); } } ================================================ FILE: tests/cases/Issue579.ts ================================================ function f(): (x: number) => any { return true ? x => f() : x => 0; } const x = 0; // no highlight in rest of file ================================================ FILE: tests/cases/Issue580.ts ================================================ (a[0] / 2) / (2) ================================================ FILE: tests/cases/Issue581.ts ================================================ interface Foo { a: () => void; b?: () => void; } ================================================ FILE: tests/cases/Issue584.ts ================================================ if (startDragXOffset < cornerDistanceThreshold > (shapeWidth - cornerDistanceThreshold)) { } if (startDragXOffset < cornerDistanceThreshold && startDragYOffset > (shapeWidth - cornerDistanceThreshold)) { } ================================================ FILE: tests/cases/Issue585.tsx ================================================ // @onlyOwnGrammar - As this has jsx const a =