tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/binder-utilities.js

@@ -22,7 +22,7 @@ export function hasStaticModifier(node) {
 /** The declaration a binding element belongs to. */
 export function getRootDeclaration(node) {
     let current = node;
-    while (current.kind === 209 /* SyntaxKind.BindingElement */)
+    while (current.kind === 210 /* SyntaxKind.BindingElement */)
         current = current.parent.parent;
     return current;
 }
@@ -31,20 +31,20 @@ export function getCombinedModifierFlags(node) {
     // Locals stay non-optional: native builds box a `Node | undefined` local at every assignment.
     let current = getRootDeclaration(node);
     let flags = getModifierFlags(current);
-    if (current.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+    if (current.kind === 262 /* SyntaxKind.VariableDeclaration */) {
         const parent = current.parent;
         if (parent === undefined)
             return flags;
         current = parent;
     }
-    if (current.kind === 262 /* SyntaxKind.VariableDeclarationList */) {
+    if (current.kind === 263 /* SyntaxKind.VariableDeclarationList */) {
         flags |= getModifierFlags(current);
         const parent = current.parent;
         if (parent === undefined)
             return flags;
         current = parent;
     }
-    if (current.kind === 244 /* SyntaxKind.VariableStatement */)
+    if (current.kind === 245 /* SyntaxKind.VariableStatement */)
         flags |= getModifierFlags(current);
     return flags;
 }
@@ -53,20 +53,20 @@ export function getCombinedNodeFlags(node) {
     // Locals stay non-optional, as in getCombinedModifierFlags.
     let current = getRootDeclaration(node);
     let flags = current.flags;
-    if (current.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+    if (current.kind === 262 /* SyntaxKind.VariableDeclaration */) {
         const parent = current.parent;
         if (parent === undefined)
             return flags;
         current = parent;
     }
-    if (current.kind === 262 /* SyntaxKind.VariableDeclarationList */) {
+    if (current.kind === 263 /* SyntaxKind.VariableDeclarationList */) {
         flags |= current.flags;
         const parent = current.parent;
         if (parent === undefined)
             return flags;
         current = parent;
     }
-    if (current.kind === 244 /* SyntaxKind.VariableStatement */)
+    if (current.kind === 245 /* SyntaxKind.VariableStatement */)
         flags |= current.flags;
     return flags;
 }
@@ -85,7 +85,7 @@ export function isJsonSourceFile(file) {
 }
 /** A source file whose declarations are global. */
 export function isGlobalSourceFile(node) {
-    return node.kind === 307 /* SyntaxKind.SourceFile */ && !isExternalOrCommonJSModule(node);
+    return node.kind === 308 /* SyntaxKind.SourceFile */ && !isExternalOrCommonJSModule(node);
 }
 export function getSourceFileOfNode(node) {
     // Walks parents without rebinding `node`, which native builds would box at every step.
@@ -101,42 +101,42 @@ export function getSourceFileOfNode(node) {
 }
 // Kinds
 export function isClassLike(node) {
-    return node.kind === 264 /* SyntaxKind.ClassDeclaration */ || node.kind === 232 /* SyntaxKind.ClassExpression */;
+    return node.kind === 265 /* SyntaxKind.ClassDeclaration */ || node.kind === 233 /* SyntaxKind.ClassExpression */;
 }
 export function isClassElement(node) {
     switch (node.kind) {
-        case 177 /* SyntaxKind.Constructor */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 182 /* SyntaxKind.IndexSignature */:
-        case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
-        case 241 /* SyntaxKind.SemicolonClassElement */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 183 /* SyntaxKind.IndexSignature */:
+        case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
+        case 242 /* SyntaxKind.SemicolonClassElement */:
             return true;
     }
     return false;
 }
 /** As the spec's IsStatic: a static class element or a static block. */
 export function isStatic(node) {
-    return (isClassElement(node) && hasStaticModifier(node)) || node.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */;
+    return (isClassElement(node) && hasStaticModifier(node)) || node.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */;
 }
 export function isDeclarationStatementKind(kind) {
     switch (kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 283 /* SyntaxKind.MissingDeclaration */:
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 265 /* SyntaxKind.InterfaceDeclaration */:
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
-        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-        case 267 /* SyntaxKind.EnumDeclaration */:
-        case 268 /* SyntaxKind.ModuleDeclaration */:
-        case 273 /* SyntaxKind.ImportDeclaration */:
-        case 346 /* SyntaxKind.JSImportDeclaration */:
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-        case 279 /* SyntaxKind.ExportDeclaration */:
-        case 278 /* SyntaxKind.ExportAssignment */:
-        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 284 /* SyntaxKind.MissingDeclaration */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 347 /* SyntaxKind.JSImportDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 280 /* SyntaxKind.ExportDeclaration */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 272 /* SyntaxKind.NamespaceExportDeclaration */:
             return true;
     }
     return false;
@@ -155,24 +155,24 @@ export function isTypeNodeKind(kind) {
         case 157 /* SyntaxKind.UndefinedKeyword */:
         case 146 /* SyntaxKind.NeverKeyword */:
         case 141 /* SyntaxKind.IntrinsicKeyword */:
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
-        case 310 /* SyntaxKind.JSDocAllType */:
-        case 311 /* SyntaxKind.JSDocNullableType */:
-        case 312 /* SyntaxKind.JSDocNonNullableType */:
-        case 313 /* SyntaxKind.JSDocOptionalType */:
-        case 314 /* SyntaxKind.JSDocVariadicType */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 311 /* SyntaxKind.JSDocAllType */:
+        case 312 /* SyntaxKind.JSDocNullableType */:
+        case 313 /* SyntaxKind.JSDocNonNullableType */:
+        case 314 /* SyntaxKind.JSDocOptionalType */:
+        case 315 /* SyntaxKind.JSDocVariadicType */:
             return true;
     }
-    return kind >= 183 /* SyntaxKind.FirstTypeNode */ && kind <= 206 /* SyntaxKind.LastTypeNode */;
+    return kind >= 184 /* SyntaxKind.FirstTypeNode */ && kind <= 207 /* SyntaxKind.LastTypeNode */;
 }
 export function isFunctionExpressionOrArrowFunction(node) {
-    return node.kind === 219 /* SyntaxKind.FunctionExpression */ || node.kind === 220 /* SyntaxKind.ArrowFunction */;
+    return node.kind === 220 /* SyntaxKind.FunctionExpression */ || node.kind === 221 /* SyntaxKind.ArrowFunction */;
 }
 export function isMethodOrAccessor(node) {
     switch (node.kind) {
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
             return true;
     }
     return false;
@@ -181,33 +181,33 @@ export function isObjectLiteralOrClassExpressionMethodOrAccessor(node) {
     if (!isMethodOrAccessor(node))
         return false;
     const parentKind = node.parent.kind;
-    return parentKind === 211 /* SyntaxKind.ObjectLiteralExpression */ || parentKind === 232 /* SyntaxKind.ClassExpression */;
+    return parentKind === 212 /* SyntaxKind.ObjectLiteralExpression */ || parentKind === 233 /* SyntaxKind.ClassExpression */;
 }
 export function isObjectLiteralMethod(node) {
     return (node !== undefined &&
-        node.kind === 175 /* SyntaxKind.MethodDeclaration */ &&
-        node.parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */);
+        node.kind === 176 /* SyntaxKind.MethodDeclaration */ &&
+        node.parent.kind === 212 /* SyntaxKind.ObjectLiteralExpression */);
 }
 export function isAutoAccessorPropertyDeclaration(node) {
-    return node.kind === 173 /* SyntaxKind.PropertyDeclaration */ && hasSyntacticModifier(node, 512 /* ModifierFlags.Accessor */);
+    return node.kind === 174 /* SyntaxKind.PropertyDeclaration */ && hasSyntacticModifier(node, 512 /* ModifierFlags.Accessor */);
 }
 export function isParameterPropertyDeclaration(node, parent) {
-    return (node.kind === 170 /* SyntaxKind.Parameter */ &&
+    return (node.kind === 171 /* SyntaxKind.Parameter */ &&
         hasSyntacticModifier(node, 31 /* ModifierFlags.ParameterPropertyModifier */) &&
-        parent.kind === 177 /* SyntaxKind.Constructor */);
+        parent.kind === 178 /* SyntaxKind.Constructor */);
 }
 export function isPrivateIdentifierClassElementDeclaration(node) {
-    if (node.kind !== 173 /* SyntaxKind.PropertyDeclaration */ && !isMethodOrAccessor(node))
+    if (node.kind !== 174 /* SyntaxKind.PropertyDeclaration */ && !isMethodOrAccessor(node))
         return false;
     const name = getName(node);
     return name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */;
 }
 export function isAsyncFunction(node) {
     switch (node.kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             return (getBody(node) !== undefined &&
                 getAsteriskToken(node) === undefined &&
                 hasSyntacticModifier(node, 1024 /* ModifierFlags.Async */));
@@ -275,17 +275,17 @@ export function isOptionalChain(node) {
     if ((node.flags & 32 /* NodeFlags.OptionalChain */) === 0)
         return false;
     switch (node.kind) {
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */:
-        case 214 /* SyntaxKind.CallExpression */:
-        case 236 /* SyntaxKind.NonNullExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
             return true;
     }
     return false;
 }
 /** The link of an optional chain with the `?.`. */
 export function isOptionalChainRoot(node) {
-    return isOptionalChain(node) && node.kind !== 236 /* SyntaxKind.NonNullExpression */ && getQuestionDotToken(node) !== undefined;
+    return isOptionalChain(node) && node.kind !== 237 /* SyntaxKind.NonNullExpression */ && getQuestionDotToken(node) !== undefined;
 }
 /** Whether `node` is the whole optional chain, not a link in a longer one. */
 export function isOutermostOptionalChain(node) {
@@ -349,7 +349,7 @@ export function isDestructuringAssignment(node) {
     if (!isAssignmentExpression(node, true))
         return false;
     const kind = node.left.kind;
-    return kind === 211 /* SyntaxKind.ObjectLiteralExpression */ || kind === 210 /* SyntaxKind.ArrayLiteralExpression */;
+    return kind === 212 /* SyntaxKind.ObjectLiteralExpression */ || kind === 211 /* SyntaxKind.ArrayLiteralExpression */;
 }
 /** The assignment, update or `for…in`/`for…of` that writes to `node`, if any. */
 export function getAssignmentTarget(node) {
@@ -357,36 +357,36 @@ export function getAssignmentTarget(node) {
     for (;;) {
         const parent = current.parent;
         switch (parent.kind) {
-            case 227 /* SyntaxKind.BinaryExpression */: {
+            case 228 /* SyntaxKind.BinaryExpression */: {
                 const binary = parent;
                 return isAssignmentOperator(binary.operatorToken.kind) && binary.left === current ? parent : undefined;
             }
-            case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+            case 226 /* SyntaxKind.PrefixUnaryExpression */: {
                 const operator = parent.operator;
                 return operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */ ? parent : undefined;
             }
-            case 226 /* SyntaxKind.PostfixUnaryExpression */: {
+            case 227 /* SyntaxKind.PostfixUnaryExpression */: {
                 const operator = parent.operator;
                 return operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */ ? parent : undefined;
             }
-            case 250 /* SyntaxKind.ForInStatement */:
-            case 251 /* SyntaxKind.ForOfStatement */:
+            case 251 /* SyntaxKind.ForInStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
                 return getInitializer(parent) === current ? parent : undefined;
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
-            case 210 /* SyntaxKind.ArrayLiteralExpression */:
-            case 231 /* SyntaxKind.SpreadElement */:
-            case 236 /* SyntaxKind.NonNullExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
+            case 211 /* SyntaxKind.ArrayLiteralExpression */:
+            case 232 /* SyntaxKind.SpreadElement */:
+            case 237 /* SyntaxKind.NonNullExpression */:
                 current = parent;
                 break;
-            case 305 /* SyntaxKind.SpreadAssignment */:
+            case 306 /* SyntaxKind.SpreadAssignment */:
                 current = parent.parent;
                 break;
-            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
                 if (getName(parent) !== current)
                     return undefined;
                 current = parent.parent;
                 break;
-            case 303 /* SyntaxKind.PropertyAssignment */:
+            case 304 /* SyntaxKind.PropertyAssignment */:
                 if (getName(parent) === current)
                     return undefined;
                 current = parent.parent;
@@ -407,12 +407,12 @@ export function isDottedName(node) {
             case 79 /* SyntaxKind.Identifier */:
             case 109 /* SyntaxKind.ThisKeyword */:
             case 107 /* SyntaxKind.SuperKeyword */:
-            case 237 /* SyntaxKind.MetaProperty */:
+            case 238 /* SyntaxKind.MetaProperty */:
                 return true;
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
                 current = current.expression;
                 break;
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
                 current = current.expression;
                 break;
             default:
@@ -439,10 +439,10 @@ export function isEntityNameExpression(node, allowJS) {
 }
 /** An `export default` or `module.exports =` expression that aliases a declaration. */
 export function expressionIsAlias(node) {
-    return isEntityNameExpression(node, false) || node.kind === 232 /* SyntaxKind.ClassExpression */;
+    return isEntityNameExpression(node, false) || node.kind === 233 /* SyntaxKind.ClassExpression */;
 }
 export function isAccessExpression(node) {
-    return node.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 213 /* SyntaxKind.ElementAccessExpression */;
+    return node.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 214 /* SyntaxKind.ElementAccessExpression */;
 }
 /** The name of `x.name` or the literal of `x["name"]`. */
 export function getElementOrPropertyAccessName(node) {
@@ -466,7 +466,7 @@ export function getImmediatelyInvokedFunctionExpression(fn) {
         return undefined;
     let prev = fn;
     let parent = fn.parent;
-    while (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */) {
+    while (parent.kind === 219 /* SyntaxKind.ParenthesizedExpression */) {
         prev = parent;
         parent = parent.parent;
     }
@@ -477,7 +477,7 @@ export function getImmediatelyInvokedFunctionExpression(fn) {
 }
 /** `x as const` or `<const>x`. */
 export function isConstAssertion(node) {
-    if (node.kind !== 235 /* SyntaxKind.AsExpression */ && node.kind !== 217 /* SyntaxKind.TypeAssertionExpression */)
+    if (node.kind !== 236 /* SyntaxKind.AsExpression */ && node.kind !== 218 /* SyntaxKind.TypeAssertionExpression */)
         return false;
     const type = getType(node);
     if (!(type instanceof TypeReferenceNode))
@@ -564,7 +564,7 @@ export function getAssignmentDeclarationKind(node) {
             return 4 /* JSDeclarationKind.Property */;
         return 0 /* JSDeclarationKind.None */;
     }
-    if (node.kind === 214 /* SyntaxKind.CallExpression */ &&
+    if (node.kind === 215 /* SyntaxKind.CallExpression */ &&
         (node.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0 &&
         isBindableObjectDefinePropertyCall(node)) {
         const entityName = getArguments(node).nodes[0];
@@ -582,15 +582,15 @@ export function isExpandoInitializer(declaration, initializer) {
         return true;
     if ((initializer.flags & 65536 /* NodeFlags.JavaScriptFile */) === 0)
         return false;
-    if (initializer.kind === 232 /* SyntaxKind.ClassExpression */)
+    if (initializer.kind === 233 /* SyntaxKind.ClassExpression */)
         return true;
-    return (initializer.kind === 211 /* SyntaxKind.ObjectLiteralExpression */ &&
+    return (initializer.kind === 212 /* SyntaxKind.ObjectLiteralExpression */ &&
         getProperties(initializer).nodes.length === 0 &&
         getType(declaration) === undefined);
 }
 /** `const x = require("m")` in JavaScript, or a binding element of one. */
 export function isVariableDeclarationInitializedToRequire(node) {
-    const candidate = node.kind === 209 /* SyntaxKind.BindingElement */ ? node.parent.parent : node;
+    const candidate = node.kind === 210 /* SyntaxKind.BindingElement */ ? node.parent.parent : node;
     if (!(candidate instanceof VariableDeclaration) ||
         (candidate.flags & 65536 /* NodeFlags.JavaScriptFile */) === 0)
         return false;
@@ -611,18 +611,18 @@ function isRequireCallWithLiteral(node) {
 /** A `@typedef` or `@callback` at the top level of a module. */
 export function isImplicitlyExportedJSDocDeclaration(node) {
     const parent = node.parent;
-    if (parent.kind !== 307 /* SyntaxKind.SourceFile */ || !isExternalOrCommonJSModule(parent))
+    if (parent.kind !== 308 /* SyntaxKind.SourceFile */ || !isExternalOrCommonJSModule(parent))
         return false;
-    if (node.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */)
+    if (node.kind === 346 /* SyntaxKind.JSTypeAliasDeclaration */)
         return true;
-    return node.kind === 268 /* SyntaxKind.ModuleDeclaration */ && (node.flags & 8 /* NodeFlags.Reparsed */) !== 0;
+    return node.kind === 269 /* SyntaxKind.ModuleDeclaration */ && (node.flags & 8 /* NodeFlags.Reparsed */) !== 0;
 }
 // Declarations
 /** The name of a declaration, not counting names it gets from an enclosing assignment. */
 export function getNonAssignedNameOfDeclaration(declaration) {
     switch (declaration.kind) {
-        case 227 /* SyntaxKind.BinaryExpression */:
-        case 214 /* SyntaxKind.CallExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
             switch (getAssignmentDeclarationKind(declaration)) {
                 case 4 /* JSDeclarationKind.Property */:
                 case 3 /* JSDeclarationKind.ThisProperty */:
@@ -636,7 +636,7 @@ export function getNonAssignedNameOfDeclaration(declaration) {
                     return getArguments(declaration).nodes[1];
             }
             return undefined;
-        case 278 /* SyntaxKind.ExportAssignment */: {
+        case 279 /* SyntaxKind.ExportAssignment */: {
             const expression = getExpression(declaration);
             return expression.kind === 79 /* SyntaxKind.Identifier */ ? expression : undefined;
         }
@@ -649,11 +649,11 @@ export function getAssignedName(node) {
     if (parent === undefined)
         return undefined;
     switch (parent.kind) {
-        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
             return getName(parent);
-        case 209 /* SyntaxKind.BindingElement */:
+        case 210 /* SyntaxKind.BindingElement */:
             return parent.name;
-        case 227 /* SyntaxKind.BinaryExpression */: {
+        case 228 /* SyntaxKind.BinaryExpression */: {
             const binary = parent;
             if (node !== binary.right)
                 return undefined;
@@ -669,7 +669,7 @@ export function getAssignedName(node) {
             }
             return undefined;
         }
-        case 261 /* SyntaxKind.VariableDeclaration */: {
+        case 262 /* SyntaxKind.VariableDeclaration */: {
             const name = parent.name;
             return name.kind === 79 /* SyntaxKind.Identifier */ ? name : undefined;
         }
@@ -682,14 +682,14 @@ export function getNameOfDeclaration(declaration) {
     const name = getNonAssignedNameOfDeclaration(declaration);
     if (name !== undefined)
         return name;
-    if (isFunctionExpressionOrArrowFunction(declaration) || declaration.kind === 232 /* SyntaxKind.ClassExpression */)
+    if (isFunctionExpressionOrArrowFunction(declaration) || declaration.kind === 233 /* SyntaxKind.ClassExpression */)
         return getAssignedName(declaration);
     return undefined;
 }
 /** A computed name or element access whose name isn't a literal. */
 export function isDynamicName(name) {
     let expression;
-    if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+    if (name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
         expression = getExpression(name);
     else if (name instanceof ElementAccessExpression)
         expression = skipParentheses(name.argumentExpression);
@@ -702,11 +702,11 @@ export function hasDynamicName(declaration) {
     return name !== undefined && isDynamicName(name);
 }
 export function isPartOfParameterDeclaration(node) {
-    return getRootDeclaration(node).kind === 170 /* SyntaxKind.Parameter */;
+    return getRootDeclaration(node).kind === 171 /* SyntaxKind.Parameter */;
 }
 export function isCatchClauseVariableDeclarationOrBindingElement(declaration) {
     const node = getRootDeclaration(declaration);
-    return node.kind === 261 /* SyntaxKind.VariableDeclaration */ && node.parent.kind === 300 /* SyntaxKind.CatchClause */;
+    return node.kind === 262 /* SyntaxKind.VariableDeclaration */ && node.parent.kind === 301 /* SyntaxKind.CatchClause */;
 }
 /** A `let`, `const`, `using` or catch variable. */
 export function isBlockOrCatchScoped(declaration) {
@@ -725,7 +725,7 @@ export function findConstructorDeclaration(node) {
     if (members === undefined)
         return undefined;
     for (const member of members.nodes)
-        if (member.kind === 177 /* SyntaxKind.Constructor */ && !nodeIsMissing(getBody(member)))
+        if (member.kind === 178 /* SyntaxKind.Constructor */ && !nodeIsMissing(getBody(member)))
             return member;
     return undefined;
 }
@@ -741,37 +741,37 @@ export function getThisContainer(node, includeArrowFunctions, includeClassComput
             throw new Error('nil parent in getThisContainer');
         current = parent;
         switch (current.kind) {
-            case 168 /* SyntaxKind.ComputedPropertyName */:
+            case 169 /* SyntaxKind.ComputedPropertyName */:
                 if (includeClassComputedPropertyName && isClassLike(current.parent.parent))
                     return current;
                 current = current.parent.parent;
                 break;
-            case 171 /* SyntaxKind.Decorator */:
-                if (current.parent.kind === 170 /* SyntaxKind.Parameter */ && isClassElement(current.parent.parent))
+            case 172 /* SyntaxKind.Decorator */:
+                if (current.parent.kind === 171 /* SyntaxKind.Parameter */ && isClassElement(current.parent.parent))
                     current = current.parent.parent;
                 else if (isClassElement(current.parent))
                     current = current.parent;
                 break;
-            case 220 /* SyntaxKind.ArrowFunction */:
+            case 221 /* SyntaxKind.ArrowFunction */:
                 if (includeArrowFunctions)
                     return current;
                 break;
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 268 /* SyntaxKind.ModuleDeclaration */:
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 172 /* SyntaxKind.PropertySignature */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 174 /* SyntaxKind.MethodSignature */:
-            case 177 /* SyntaxKind.Constructor */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 180 /* SyntaxKind.CallSignature */:
-            case 181 /* SyntaxKind.ConstructSignature */:
-            case 182 /* SyntaxKind.IndexSignature */:
-            case 267 /* SyntaxKind.EnumDeclaration */:
-            case 307 /* SyntaxKind.SourceFile */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 173 /* SyntaxKind.PropertySignature */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 175 /* SyntaxKind.MethodSignature */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 181 /* SyntaxKind.CallSignature */:
+            case 182 /* SyntaxKind.ConstructSignature */:
+            case 183 /* SyntaxKind.IndexSignature */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
+            case 308 /* SyntaxKind.SourceFile */:
                 return current;
         }
     }
@@ -781,49 +781,49 @@ export function isInTopLevelContext(node) {
     let current = node;
     if (current.kind === 79 /* SyntaxKind.Identifier */) {
         const parent = current.parent;
-        if ((parent.kind === 264 /* SyntaxKind.ClassDeclaration */ || parent.kind === 263 /* SyntaxKind.FunctionDeclaration */) &&
+        if ((parent.kind === 265 /* SyntaxKind.ClassDeclaration */ || parent.kind === 264 /* SyntaxKind.FunctionDeclaration */) &&
             getName(parent) === current)
             current = parent;
     }
-    return getThisContainer(current, true, false).kind === 307 /* SyntaxKind.SourceFile */;
+    return getThisContainer(current, true, false).kind === 308 /* SyntaxKind.SourceFile */;
 }
 /** An identifier in a property name position, which never resolves to a symbol. */
 export function isIdentifierName(node) {
     const parent = node.parent;
     switch (parent.kind) {
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 174 /* SyntaxKind.MethodSignature */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 306 /* SyntaxKind.EnumMember */:
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 307 /* SyntaxKind.EnumMember */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
             return getName(parent) === node;
-        case 167 /* SyntaxKind.QualifiedName */:
+        case 168 /* SyntaxKind.QualifiedName */:
             return parent.right === node;
-        case 209 /* SyntaxKind.BindingElement */:
-        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 210 /* SyntaxKind.BindingElement */:
+        case 278 /* SyntaxKind.ImportSpecifier */:
             return getPropertyName(parent) === node;
-        case 282 /* SyntaxKind.ExportSpecifier */:
-        case 292 /* SyntaxKind.JsxAttribute */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
-        case 287 /* SyntaxKind.JsxOpeningElement */:
-        case 288 /* SyntaxKind.JsxClosingElement */:
+        case 283 /* SyntaxKind.ExportSpecifier */:
+        case 293 /* SyntaxKind.JsxAttribute */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 289 /* SyntaxKind.JsxClosingElement */:
             return true;
     }
     return false;
 }
 export function isPartOfTypeQuery(node) {
     let current = node;
-    while (current.kind === 167 /* SyntaxKind.QualifiedName */ || current.kind === 79 /* SyntaxKind.Identifier */)
+    while (current.kind === 168 /* SyntaxKind.QualifiedName */ || current.kind === 79 /* SyntaxKind.Identifier */)
         current = current.parent;
-    return current.kind === 187 /* SyntaxKind.TypeQuery */;
+    return current.kind === 188 /* SyntaxKind.TypeQuery */;
 }
 /** A statement that runs code, or a declaration that does (classes, enums, namespaces). */
 export function isPotentiallyExecutableNode(node) {
-    if (node.kind >= 244 /* SyntaxKind.FirstStatement */ && node.kind <= 260 /* SyntaxKind.LastStatement */) {
+    if (node.kind >= 245 /* SyntaxKind.FirstStatement */ && node.kind <= 261 /* SyntaxKind.LastStatement */) {
         if (node instanceof VariableStatement) {
             const list = node.declarationList;
             if ((getCombinedNodeFlags(list) & 7 /* NodeFlags.BlockScoped */) !== 0)
@@ -835,21 +835,21 @@ export function isPotentiallyExecutableNode(node) {
         }
         return true;
     }
-    return (node.kind === 264 /* SyntaxKind.ClassDeclaration */ ||
-        node.kind === 267 /* SyntaxKind.EnumDeclaration */ ||
-        node.kind === 268 /* SyntaxKind.ModuleDeclaration */);
+    return (node.kind === 265 /* SyntaxKind.ClassDeclaration */ ||
+        node.kind === 268 /* SyntaxKind.EnumDeclaration */ ||
+        node.kind === 269 /* SyntaxKind.ModuleDeclaration */);
 }
 /** A `declare module "m"` that augments an external module rather than declaring one. */
 export function isModuleAugmentationExternal(node) {
     const parent = node.parent;
     switch (parent.kind) {
-        case 307 /* SyntaxKind.SourceFile */:
+        case 308 /* SyntaxKind.SourceFile */:
             return isExternalModule(parent);
-        case 269 /* SyntaxKind.ModuleBlock */: {
+        case 270 /* SyntaxKind.ModuleBlock */: {
             const grandParent = parent.parent;
             return (grandParent instanceof ModuleDeclaration &&
                 isAmbientModuleDeclaration(grandParent) &&
-                grandParent.parent.kind === 307 /* SyntaxKind.SourceFile */ &&
+                grandParent.parent.kind === 308 /* SyntaxKind.SourceFile */ &&
                 !isExternalModule(grandParent.parent));
         }
     }
@@ -952,25 +952,25 @@ class ModuleInstanceStateComputer extends NodeVisitor {
     }
     worker(node, ancestors) {
         switch (node.kind) {
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
-            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
                 return 1 /* ModuleInstanceState.NonInstantiated */;
-            case 267 /* SyntaxKind.EnumDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
                 if (isEnumConst(node))
                     return 3 /* ModuleInstanceState.ConstEnumOnly */;
                 break;
-            case 273 /* SyntaxKind.ImportDeclaration */:
-            case 346 /* SyntaxKind.JSImportDeclaration */:
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
+            case 347 /* SyntaxKind.JSImportDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
                 if (!hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
                     return 1 /* ModuleInstanceState.NonInstantiated */;
                 break;
-            case 279 /* SyntaxKind.ExportDeclaration */: {
+            case 280 /* SyntaxKind.ExportDeclaration */: {
                 const exportClause = node.exportClause;
                 if (node.moduleSpecifier === undefined &&
                     exportClause !== undefined &&
-                    exportClause.kind === 280 /* SyntaxKind.NamedExports */) {
+                    exportClause.kind === 281 /* SyntaxKind.NamedExports */) {
                     let state = 1 /* ModuleInstanceState.NonInstantiated */;
                     const specifierAncestors = withAncestor(withAncestor(ancestors, node), exportClause);
                     for (const specifier of getElements(exportClause).nodes) {
@@ -984,7 +984,7 @@ class ModuleInstanceStateComputer extends NodeVisitor {
                 }
                 break;
             }
-            case 269 /* SyntaxKind.ModuleBlock */: {
+            case 270 /* SyntaxKind.ModuleBlock */: {
                 const saveAncestors = this.blockAncestors;
                 const saveState = this.blockState;
                 this.blockAncestors = withAncestor(ancestors, node);
@@ -995,7 +995,7 @@ class ModuleInstanceStateComputer extends NodeVisitor {
                 this.blockState = saveState;
                 return state;
             }
-            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
                 return this.ofModule(node, ancestors);
         }
         return 2 /* ModuleInstanceState.Instantiated */;
@@ -1030,7 +1030,7 @@ class ModuleInstanceStateComputer extends NodeVisitor {
                 p = ancestors[--remaining];
             if (p === undefined)
                 break;
-            if (p.kind !== 242 /* SyntaxKind.Block */ && p.kind !== 269 /* SyntaxKind.ModuleBlock */ && p.kind !== 307 /* SyntaxKind.SourceFile */)
+            if (p.kind !== 243 /* SyntaxKind.Block */ && p.kind !== 270 /* SyntaxKind.ModuleBlock */ && p.kind !== 308 /* SyntaxKind.SourceFile */)
                 continue;
             let found = 0 /* ModuleInstanceState.Unknown */;
             const statementsAncestors = ancestors.slice(0, remaining);
@@ -1042,7 +1042,7 @@ class ModuleInstanceStateComputer extends NodeVisitor {
                 if (found === 2 /* ModuleInstanceState.Instantiated */)
                     return found;
                 // A re-exported import alias is ambiguous, like `export import x = mod.x`.
-                if (statement.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */)
+                if (statement.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */)
                     found = 2 /* ModuleInstanceState.Instantiated */;
             }
             if (found !== 0 /* ModuleInstanceState.Unknown */)
@@ -1119,7 +1119,7 @@ function getErrorRangeForArrowFunction(file, node) {
     const text = file.text;
     const pos = skipTrivia(text, node.pos);
     const body = getBody(node);
-    if (body !== undefined && body.kind === 242 /* SyntaxKind.Block */) {
+    if (body !== undefined && body.kind === 243 /* SyntaxKind.Block */) {
         const lineStarts = file.lineStarts();
         const startLine = computeLineOfPosition(lineStarts, body.pos);
         const endLine = computeLineOfPosition(lineStarts, body.end);
@@ -1169,53 +1169,53 @@ export function getErrorRangeForNode(file, node) {
     const text = file.text;
     let errorNode = node;
     switch (node.kind) {
-        case 307 /* SyntaxKind.SourceFile */: {
+        case 308 /* SyntaxKind.SourceFile */: {
             const pos = skipTrivia(text, 0);
             return pos === text.length ? new TextRange(0, 0) : getRangeOfTokenAtPosition(file, pos);
         }
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             if ((node.flags & 8 /* NodeFlags.Reparsed */) === 0)
                 errorNode = getNameOfDeclaration(node);
             break;
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 209 /* SyntaxKind.BindingElement */:
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 265 /* SyntaxKind.InterfaceDeclaration */:
-        case 268 /* SyntaxKind.ModuleDeclaration */:
-        case 267 /* SyntaxKind.EnumDeclaration */:
-        case 306 /* SyntaxKind.EnumMember */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
-        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 275 /* SyntaxKind.NamespaceImport */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 210 /* SyntaxKind.BindingElement */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
+        case 307 /* SyntaxKind.EnumMember */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 276 /* SyntaxKind.NamespaceImport */:
             errorNode = getNameOfDeclaration(node);
             break;
-        case 232 /* SyntaxKind.ClassExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
             errorNode = getName(node);
             break;
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             return getErrorRangeForArrowFunction(file, node);
-        case 297 /* SyntaxKind.CaseClause */:
-        case 298 /* SyntaxKind.DefaultClause */: {
+        case 298 /* SyntaxKind.CaseClause */:
+        case 299 /* SyntaxKind.DefaultClause */: {
             const start = skipTrivia(text, node.pos);
             const statements = getStatements(node).nodes;
             return new TextRange(start, statements.length !== 0 ? statements[0].pos : node.end);
         }
-        case 254 /* SyntaxKind.ReturnStatement */:
-        case 230 /* SyntaxKind.YieldExpression */:
+        case 255 /* SyntaxKind.ReturnStatement */:
+        case 231 /* SyntaxKind.YieldExpression */:
             return getRangeOfTokenAtPosition(file, skipTrivia(text, node.pos));
-        case 239 /* SyntaxKind.SatisfiesExpression */: {
+        case 240 /* SyntaxKind.SatisfiesExpression */: {
             const tag = findOriginatingJSDocSatisfiesTag(file, node);
             if (tag !== undefined)
                 return getRangeOfTokenAtPosition(file, skipTrivia(text, getTagName(tag).pos));
             return getRangeOfTokenAtPosition(file, skipTrivia(text, getExpression(node).end));
         }
-        case 177 /* SyntaxKind.Constructor */: {
+        case 178 /* SyntaxKind.Constructor */: {
             if ((node.flags & 8 /* NodeFlags.Reparsed */) !== 0)
                 break;
             const scanner = scannerAt(file, node.pos);