tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,1240 @@
+// Syntax queries the binder, name resolver and checker share, ported from tsgo's ast and
+// scanner utilities.
+//
+// Fields of `instanceof`-narrowed nodes are read through `as` casts: scriptc reads them
+// statically, but reads fields of a narrowed value dynamically.
+import { BinaryExpression, CallExpression, ElementAccessExpression, ExpressionStatement, Identifier, JSDoc, JSDocSatisfiesTag, JsxNamespacedName, MetaProperty, ModuleDeclaration, NodeVisitor, PrefixUnaryExpression, ParenthesizedExpression, PropertyAccessExpression, TaggedTemplateExpression, TypeReferenceNode, VariableDeclaration, VariableStatement, getArguments, getAsteriskToken, getBody, getElements, getExpression, getInitializer, getMembers, getModifiers, getName, getProperties, getPropertyName, getStatements, getTagName, getText, getType, } from './ast.js';
+import { getJSDoc } from './parser.js';
+import { isAssignmentOperator, isLeftHandSideExpression, isStringLiteralLike, nodeIsMissing } from './ast-utilities.js';
+import { Scanner, computeLineOfPosition, skipTrivia } from './scanner.js';
+// Modifiers and flags
+export function getModifierFlags(node) {
+    const modifiers = getModifiers(node);
+    return modifiers === undefined ? 0 /* ModifierFlags.None */ : modifiers.modifierFlags;
+}
+export function hasSyntacticModifier(node, flags) {
+    return (getModifierFlags(node) & flags) !== 0;
+}
+export function hasStaticModifier(node) {
+    return hasSyntacticModifier(node, 256 /* ModifierFlags.Static */);
+}
+/** The declaration a binding element belongs to. */
+export function getRootDeclaration(node) {
+    let current = node;
+    while (current.kind === 209 /* SyntaxKind.BindingElement */)
+        current = current.parent.parent;
+    return current;
+}
+/** Modifier flags of a variable declaration combined with its list's and statement's. */
+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 */) {
+        const parent = current.parent;
+        if (parent === undefined)
+            return flags;
+        current = parent;
+    }
+    if (current.kind === 262 /* SyntaxKind.VariableDeclarationList */) {
+        flags |= getModifierFlags(current);
+        const parent = current.parent;
+        if (parent === undefined)
+            return flags;
+        current = parent;
+    }
+    if (current.kind === 244 /* SyntaxKind.VariableStatement */)
+        flags |= getModifierFlags(current);
+    return flags;
+}
+/** Node flags of a variable declaration combined with its list's and statement's. */
+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 */) {
+        const parent = current.parent;
+        if (parent === undefined)
+            return flags;
+        current = parent;
+    }
+    if (current.kind === 262 /* SyntaxKind.VariableDeclarationList */) {
+        flags |= current.flags;
+        const parent = current.parent;
+        if (parent === undefined)
+            return flags;
+        current = parent;
+    }
+    if (current.kind === 244 /* SyntaxKind.VariableStatement */)
+        flags |= current.flags;
+    return flags;
+}
+export function isEnumConst(node) {
+    return (getCombinedModifierFlags(node) & 4096 /* ModifierFlags.Const */) !== 0;
+}
+// Source files
+export function isExternalModule(file) {
+    return file.externalModuleIndicator !== undefined;
+}
+export function isExternalOrCommonJSModule(file) {
+    return file.externalModuleIndicator !== undefined || file.commonJSModuleIndicator !== undefined;
+}
+export function isJsonSourceFile(file) {
+    return file.scriptKind === 6 /* ScriptKind.JSON */;
+}
+/** A source file whose declarations are global. */
+export function isGlobalSourceFile(node) {
+    return node.kind === 307 /* SyntaxKind.SourceFile */ && !isExternalOrCommonJSModule(node);
+}
+export function getSourceFileOfNode(node) {
+    // Walks parents without rebinding `node`, which native builds would box at every step.
+    let parent = node.parent;
+    if (parent === undefined)
+        return node;
+    for (;;) {
+        const next = parent.parent;
+        if (next === undefined)
+            return parent;
+        parent = next;
+    }
+}
+// Kinds
+export function isClassLike(node) {
+    return node.kind === 264 /* SyntaxKind.ClassDeclaration */ || node.kind === 232 /* 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 */:
+            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 */;
+}
+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 */:
+            return true;
+    }
+    return false;
+}
+export function isTypeNodeKind(kind) {
+    switch (kind) {
+        case 132 /* SyntaxKind.AnyKeyword */:
+        case 159 /* SyntaxKind.UnknownKeyword */:
+        case 150 /* SyntaxKind.NumberKeyword */:
+        case 163 /* SyntaxKind.BigIntKeyword */:
+        case 151 /* SyntaxKind.ObjectKeyword */:
+        case 135 /* SyntaxKind.BooleanKeyword */:
+        case 154 /* SyntaxKind.StringKeyword */:
+        case 155 /* SyntaxKind.SymbolKeyword */:
+        case 115 /* SyntaxKind.VoidKeyword */:
+        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 */:
+            return true;
+    }
+    return kind >= 183 /* SyntaxKind.FirstTypeNode */ && kind <= 206 /* SyntaxKind.LastTypeNode */;
+}
+export function isFunctionExpressionOrArrowFunction(node) {
+    return node.kind === 219 /* SyntaxKind.FunctionExpression */ || node.kind === 220 /* SyntaxKind.ArrowFunction */;
+}
+export function isMethodOrAccessor(node) {
+    switch (node.kind) {
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+            return true;
+    }
+    return false;
+}
+export function isObjectLiteralOrClassExpressionMethodOrAccessor(node) {
+    if (!isMethodOrAccessor(node))
+        return false;
+    const parentKind = node.parent.kind;
+    return parentKind === 211 /* SyntaxKind.ObjectLiteralExpression */ || parentKind === 232 /* SyntaxKind.ClassExpression */;
+}
+export function isObjectLiteralMethod(node) {
+    return (node !== undefined &&
+        node.kind === 175 /* SyntaxKind.MethodDeclaration */ &&
+        node.parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */);
+}
+export function isAutoAccessorPropertyDeclaration(node) {
+    return node.kind === 173 /* SyntaxKind.PropertyDeclaration */ && hasSyntacticModifier(node, 512 /* ModifierFlags.Accessor */);
+}
+export function isParameterPropertyDeclaration(node, parent) {
+    return (node.kind === 170 /* SyntaxKind.Parameter */ &&
+        hasSyntacticModifier(node, 31 /* ModifierFlags.ParameterPropertyModifier */) &&
+        parent.kind === 177 /* SyntaxKind.Constructor */);
+}
+export function isPrivateIdentifierClassElementDeclaration(node) {
+    if (node.kind !== 173 /* 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 */:
+            return (getBody(node) !== undefined &&
+                getAsteriskToken(node) === undefined &&
+                hasSyntacticModifier(node, 1024 /* ModifierFlags.Async */));
+    }
+    return false;
+}
+export function isStringOrNumericLiteralLike(node) {
+    return isStringLiteralLike(node) || node.kind === 8 /* SyntaxKind.NumericLiteral */;
+}
+export function isSignedNumericLiteral(node) {
+    return (node instanceof PrefixUnaryExpression &&
+        (node.operator === 39 /* SyntaxKind.PlusToken */ ||
+            node.operator === 40 /* SyntaxKind.MinusToken */) &&
+        node.operand.kind === 8 /* SyntaxKind.NumericLiteral */);
+}
+export function isPropertyNameLiteral(node) {
+    switch (node.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+            return true;
+    }
+    return false;
+}
+export function isBooleanLiteral(node) {
+    return node.kind === 111 /* SyntaxKind.TrueKeyword */ || node.kind === 96 /* SyntaxKind.FalseKeyword */;
+}
+export function isPrologueDirective(node) {
+    return (node instanceof ExpressionStatement && node.expression.kind === 10 /* SyntaxKind.StringLiteral */);
+}
+/** The text of an identifier, literal, meta property or JSX namespaced name. */
+export function nodeText(node) {
+    if (node instanceof JsxNamespacedName) {
+        const namespaced = node;
+        return namespaced.namespace.text + ':' + namespaced.name.text;
+    }
+    if (node instanceof MetaProperty)
+        return node.name.text;
+    return getText(node);
+}
+export function isIdentifierNamed(node, name) {
+    return node instanceof Identifier && node.text === name;
+}
+// Expressions
+/** `node` without enclosing parentheses. */
+export function skipParentheses(node) {
+    let current = node;
+    while (current instanceof ParenthesizedExpression)
+        current = current.expression;
+    return current;
+}
+function getQuestionDotToken(node) {
+    if (node instanceof PropertyAccessExpression)
+        return node.questionDotToken;
+    if (node instanceof ElementAccessExpression)
+        return node.questionDotToken;
+    if (node instanceof CallExpression)
+        return node.questionDotToken;
+    if (node instanceof TaggedTemplateExpression)
+        return node.questionDotToken;
+    return undefined;
+}
+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 */:
+            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;
+}
+/** Whether `node` is the whole optional chain, not a link in a longer one. */
+export function isOutermostOptionalChain(node) {
+    const parent = node.parent;
+    return !isOptionalChain(parent) || isOptionalChainRoot(parent) || node !== getExpression(parent);
+}
+export function isExpressionOfOptionalChainRoot(node) {
+    const parent = node.parent;
+    return isOptionalChainRoot(parent) && getExpression(parent) === node;
+}
+export function isNullishCoalesce(node) {
+    return (node instanceof BinaryExpression &&
+        node.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */);
+}
+export function isLogicalOrCoalescingBinaryOperator(kind) {
+    return (kind === 56 /* SyntaxKind.BarBarToken */ ||
+        kind === 55 /* SyntaxKind.AmpersandAmpersandToken */ ||
+        kind === 60 /* SyntaxKind.QuestionQuestionToken */);
+}
+export function isLogicalOrCoalescingAssignmentOperator(kind) {
+    return (kind === 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */ ||
+        kind === 75 /* SyntaxKind.BarBarEqualsToken */ ||
+        kind === 77 /* SyntaxKind.QuestionQuestionEqualsToken */);
+}
+export function isLogicalOrCoalescingAssignmentExpression(node) {
+    return (node instanceof BinaryExpression &&
+        isLogicalOrCoalescingAssignmentOperator(node.operatorToken.kind));
+}
+/** `&&`, `||` or `??`, possibly parenthesized or negated. */
+export function isLogicalExpression(node) {
+    let current = node;
+    for (;;) {
+        if (current instanceof ParenthesizedExpression) {
+            const parenthesized = current;
+            current = parenthesized.expression;
+        }
+        else if (current instanceof PrefixUnaryExpression) {
+            const unary = current;
+            if (unary.operator !== 53 /* SyntaxKind.ExclamationToken */)
+                return false;
+            current = unary.operand;
+        }
+        else if (current instanceof BinaryExpression) {
+            const binary = current;
+            return isLogicalOrCoalescingBinaryOperator(binary.operatorToken.kind);
+        }
+        else
+            return false;
+    }
+}
+export function isAssignmentExpression(node, excludeCompoundAssignment) {
+    if (!(node instanceof BinaryExpression))
+        return false;
+    const binary = node;
+    const operator = binary.operatorToken.kind;
+    return ((operator === 63 /* SyntaxKind.EqualsToken */ || (!excludeCompoundAssignment && isAssignmentOperator(operator))) &&
+        isLeftHandSideExpression(binary.left));
+}
+/** `[a, b] = …` or `({ a } = …)`. */
+export function isDestructuringAssignment(node) {
+    if (!isAssignmentExpression(node, true))
+        return false;
+    const kind = node.left.kind;
+    return kind === 211 /* SyntaxKind.ObjectLiteralExpression */ || kind === 210 /* SyntaxKind.ArrayLiteralExpression */;
+}
+/** The assignment, update or `for…in`/`for…of` that writes to `node`, if any. */
+export function getAssignmentTarget(node) {
+    let current = node;
+    for (;;) {
+        const parent = current.parent;
+        switch (parent.kind) {
+            case 227 /* SyntaxKind.BinaryExpression */: {
+                const binary = parent;
+                return isAssignmentOperator(binary.operatorToken.kind) && binary.left === current ? parent : undefined;
+            }
+            case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+                const operator = parent.operator;
+                return operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */ ? parent : undefined;
+            }
+            case 226 /* 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 */:
+                return getInitializer(parent) === current ? parent : undefined;
+            case 218 /* SyntaxKind.ParenthesizedExpression */:
+            case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            case 231 /* SyntaxKind.SpreadElement */:
+            case 236 /* SyntaxKind.NonNullExpression */:
+                current = parent;
+                break;
+            case 305 /* SyntaxKind.SpreadAssignment */:
+                current = parent.parent;
+                break;
+            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+                if (getName(parent) !== current)
+                    return undefined;
+                current = parent.parent;
+                break;
+            case 303 /* SyntaxKind.PropertyAssignment */:
+                if (getName(parent) === current)
+                    return undefined;
+                current = parent.parent;
+                break;
+            default:
+                return undefined;
+        }
+    }
+}
+export function isAssignmentTarget(node) {
+    return getAssignmentTarget(node) !== undefined;
+}
+/** An identifier, `this`, `super` or `import.meta`, possibly with property accesses. */
+export function isDottedName(node) {
+    let current = node;
+    for (;;) {
+        switch (current.kind) {
+            case 79 /* SyntaxKind.Identifier */:
+            case 109 /* SyntaxKind.ThisKeyword */:
+            case 107 /* SyntaxKind.SuperKeyword */:
+            case 237 /* SyntaxKind.MetaProperty */:
+                return true;
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+                current = current.expression;
+                break;
+            case 218 /* SyntaxKind.ParenthesizedExpression */:
+                current = current.expression;
+                break;
+            default:
+                return false;
+        }
+    }
+}
+/** `a`, `a.b.c`, and in JavaScript `this.a` and `a["b"]`. */
+export function isEntityNameExpression(node, allowJS) {
+    if (node.kind === 79 /* SyntaxKind.Identifier */)
+        return true;
+    if (node instanceof PropertyAccessExpression) {
+        const access = node;
+        return access.name.kind === 79 /* SyntaxKind.Identifier */ && isEntityNameExpression(access.expression, allowJS);
+    }
+    if (!allowJS)
+        return false;
+    if (node.kind === 109 /* SyntaxKind.ThisKeyword */)
+        return true;
+    if (!(node instanceof ElementAccessExpression))
+        return false;
+    const access = node;
+    return isStringOrNumericLiteralLike(access.argumentExpression) && isEntityNameExpression(access.expression, 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 */;
+}
+export function isAccessExpression(node) {
+    return node.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 213 /* SyntaxKind.ElementAccessExpression */;
+}
+/** The name of `x.name` or the literal of `x["name"]`. */
+export function getElementOrPropertyAccessName(node) {
+    if (node instanceof PropertyAccessExpression)
+        return node.name.kind === 79 /* SyntaxKind.Identifier */
+            ? node.name
+            : undefined;
+    if (node instanceof ElementAccessExpression) {
+        const argument = skipParentheses(node.argumentExpression);
+        return isStringOrNumericLiteralLike(argument) ? argument : undefined;
+    }
+    throw new Error('Unhandled case in getElementOrPropertyAccessName');
+}
+export function isPushOrUnshiftIdentifier(node) {
+    const text = getText(node);
+    return text === 'push' || text === 'unshift';
+}
+/** The call of an immediately invoked function or arrow function. */
+export function getImmediatelyInvokedFunctionExpression(fn) {
+    if (!isFunctionExpressionOrArrowFunction(fn))
+        return undefined;
+    let prev = fn;
+    let parent = fn.parent;
+    while (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */) {
+        prev = parent;
+        parent = parent.parent;
+    }
+    if (!(parent instanceof CallExpression))
+        return undefined;
+    const call = parent;
+    return call.expression === prev ? call : undefined;
+}
+/** `x as const` or `<const>x`. */
+export function isConstAssertion(node) {
+    if (node.kind !== 235 /* SyntaxKind.AsExpression */ && node.kind !== 217 /* SyntaxKind.TypeAssertionExpression */)
+        return false;
+    const type = getType(node);
+    if (!(type instanceof TypeReferenceNode))
+        return false;
+    const typeArguments = type.typeArguments;
+    return ((typeArguments === undefined || typeArguments.nodes.length === 0) &&
+        isIdentifierNamed(type.typeName, 'const'));
+}
+export function isModuleIdentifier(node) {
+    return isIdentifierNamed(node, 'module');
+}
+export function isExportsIdentifier(node) {
+    return isIdentifierNamed(node, 'exports');
+}
+/** `module.exports` or `module["exports"]`. */
+export function isModuleExportsAccessExpression(node) {
+    if (!isAccessExpression(node) || !isModuleIdentifier(getExpression(node)))
+        return false;
+    const name = getElementOrPropertyAccessName(node);
+    return name !== undefined && getText(name) === 'exports';
+}
+function isLiteralLikeElementAccess(node) {
+    return (node instanceof ElementAccessExpression &&
+        isStringOrNumericLiteralLike(node.argumentExpression));
+}
+export function isBindableStaticAccessExpression(node, excludeThisKeyword) {
+    if (node instanceof PropertyAccessExpression) {
+        if (!excludeThisKeyword && node.expression.kind === 109 /* SyntaxKind.ThisKeyword */)
+            return true;
+        if (node.name.kind === 79 /* SyntaxKind.Identifier */ &&
+            isBindableStaticNameExpression(node.expression, true))
+            return true;
+    }
+    return isBindableStaticElementAccessExpression(node, excludeThisKeyword);
+}
+export function isBindableStaticElementAccessExpression(node, excludeThisKeyword) {
+    if (!isLiteralLikeElementAccess(node))
+        return false;
+    const expression = node.expression;
+    return ((!excludeThisKeyword && expression.kind === 109 /* SyntaxKind.ThisKeyword */) ||
+        isEntityNameExpression(expression, false) ||
+        isBindableStaticAccessExpression(expression, true));
+}
+export function isBindableStaticNameExpression(node, excludeThisKeyword) {
+    return isEntityNameExpression(node, false) || isBindableStaticAccessExpression(node, excludeThisKeyword);
+}
+/** `Object.defineProperty(x, "name", descriptor)` with a bindable `x`. */
+export function isBindableObjectDefinePropertyCall(node) {
+    if (!(node instanceof CallExpression))
+        return false;
+    const args = node.arguments.nodes;
+    if (args.length !== 3)
+        return false;
+    const callee = node.expression;
+    return (callee instanceof PropertyAccessExpression &&
+        isIdentifierNamed(callee.expression, 'Object') &&
+        getText(callee.name) === 'defineProperty' &&
+        isStringOrNumericLiteralLike(args[1]) &&
+        isBindableStaticNameExpression(args[0], true));
+}
+export function getAssignmentDeclarationKind(node) {
+    if (node instanceof BinaryExpression) {
+        const binary = node;
+        const left = binary.left;
+        if (binary.operatorToken.kind !== 63 /* SyntaxKind.EqualsToken */ || !isAccessExpression(left))
+            return 0 /* JSDeclarationKind.None */;
+        const inJS = (left.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0;
+        const target = getExpression(left);
+        if (inJS) {
+            if (isModuleExportsAccessExpression(left) && !isExportsIdentifier(binary.right))
+                return 1 /* JSDeclarationKind.ModuleExports */;
+            if ((isModuleExportsAccessExpression(target) || isExportsIdentifier(target)) &&
+                getElementOrPropertyAccessName(left) !== undefined)
+                return 2 /* JSDeclarationKind.ExportsProperty */;
+            if (target.kind === 109 /* SyntaxKind.ThisKeyword */)
+                return 3 /* JSDeclarationKind.ThisProperty */;
+        }
+        if (left instanceof PropertyAccessExpression) {
+            if (isEntityNameExpression(target, inJS) &&
+                left.name.kind === 79 /* SyntaxKind.Identifier */)
+                return 4 /* JSDeclarationKind.Property */;
+        }
+        else if (isEntityNameExpression(target, inJS))
+            return 4 /* JSDeclarationKind.Property */;
+        return 0 /* JSDeclarationKind.None */;
+    }
+    if (node.kind === 214 /* SyntaxKind.CallExpression */ &&
+        (node.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0 &&
+        isBindableObjectDefinePropertyCall(node)) {
+        const entityName = getArguments(node).nodes[0];
+        return isExportsIdentifier(entityName) || isModuleExportsAccessExpression(entityName)
+            ? 6 /* JSDeclarationKind.ObjectDefinePropertyExports */
+            : 5 /* JSDeclarationKind.ObjectDefinePropertyValue */;
+    }
+    return 0 /* JSDeclarationKind.None */;
+}
+/** A function, arrow or (in JavaScript) class expression or empty object literal that can get expando properties. */
+export function isExpandoInitializer(declaration, initializer) {
+    if (initializer === undefined)
+        return false;
+    if (isFunctionExpressionOrArrowFunction(initializer))
+        return true;
+    if ((initializer.flags & 65536 /* NodeFlags.JavaScriptFile */) === 0)
+        return false;
+    if (initializer.kind === 232 /* SyntaxKind.ClassExpression */)
+        return true;
+    return (initializer.kind === 211 /* 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;
+    if (!(candidate instanceof VariableDeclaration) ||
+        (candidate.flags & 65536 /* NodeFlags.JavaScriptFile */) === 0)
+        return false;
+    const declaration = candidate;
+    const initializer = declaration.initializer;
+    if (initializer === undefined)
+        return false;
+    return ((getModifierFlags(declaration.parent.parent) & 32 /* ModifierFlags.Export */) === 0 &&
+        declaration.type === undefined &&
+        isRequireCallWithLiteral(initializer));
+}
+function isRequireCallWithLiteral(node) {
+    if (!(node instanceof CallExpression) || !isIdentifierNamed(node.expression, 'require'))
+        return false;
+    const args = node.arguments.nodes;
+    return args.length === 1 && isStringLiteralLike(args[0]);
+}
+/** 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))
+        return false;
+    if (node.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */)
+        return true;
+    return node.kind === 268 /* 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 */:
+            switch (getAssignmentDeclarationKind(declaration)) {
+                case 4 /* JSDeclarationKind.Property */:
+                case 3 /* JSDeclarationKind.ThisProperty */:
+                case 2 /* JSDeclarationKind.ExportsProperty */: {
+                    const left = declaration.left;
+                    const name = getElementOrPropertyAccessName(left);
+                    return name !== undefined ? name : left;
+                }
+                case 5 /* JSDeclarationKind.ObjectDefinePropertyValue */:
+                case 6 /* JSDeclarationKind.ObjectDefinePropertyExports */:
+                    return getArguments(declaration).nodes[1];
+            }
+            return undefined;
+        case 278 /* SyntaxKind.ExportAssignment */: {
+            const expression = getExpression(declaration);
+            return expression.kind === 79 /* SyntaxKind.Identifier */ ? expression : undefined;
+        }
+    }
+    return getName(declaration);
+}
+/** The name a function or class expression gets from the property, variable or assignment it initializes. */
+export function getAssignedName(node) {
+    const parent = node.parent;
+    if (parent === undefined)
+        return undefined;
+    switch (parent.kind) {
+        case 303 /* SyntaxKind.PropertyAssignment */:
+            return getName(parent);
+        case 209 /* SyntaxKind.BindingElement */:
+            return parent.name;
+        case 227 /* SyntaxKind.BinaryExpression */: {
+            const binary = parent;
+            if (node !== binary.right)
+                return undefined;
+            const left = binary.left;
+            if (left.kind === 79 /* SyntaxKind.Identifier */)
+                return left;
+            if (left instanceof PropertyAccessExpression)
+                return left.name;
+            if (left instanceof ElementAccessExpression) {
+                const argument = skipParentheses(left.argumentExpression);
+                if (isStringOrNumericLiteralLike(argument))
+                    return argument;
+            }
+            return undefined;
+        }
+        case 261 /* SyntaxKind.VariableDeclaration */: {
+            const name = parent.name;
+            return name.kind === 79 /* SyntaxKind.Identifier */ ? name : undefined;
+        }
+    }
+    return undefined;
+}
+export function getNameOfDeclaration(declaration) {
+    if (declaration === undefined)
+        return undefined;
+    const name = getNonAssignedNameOfDeclaration(declaration);
+    if (name !== undefined)
+        return name;
+    if (isFunctionExpressionOrArrowFunction(declaration) || declaration.kind === 232 /* 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 */)
+        expression = getExpression(name);
+    else if (name instanceof ElementAccessExpression)
+        expression = skipParentheses(name.argumentExpression);
+    else
+        return false;
+    return !isStringOrNumericLiteralLike(expression) && !isSignedNumericLiteral(expression);
+}
+export function hasDynamicName(declaration) {
+    const name = getNameOfDeclaration(declaration);
+    return name !== undefined && isDynamicName(name);
+}
+export function isPartOfParameterDeclaration(node) {
+    return getRootDeclaration(node).kind === 170 /* SyntaxKind.Parameter */;
+}
+export function isCatchClauseVariableDeclarationOrBindingElement(declaration) {
+    const node = getRootDeclaration(declaration);
+    return node.kind === 261 /* SyntaxKind.VariableDeclaration */ && node.parent.kind === 300 /* SyntaxKind.CatchClause */;
+}
+/** A `let`, `const`, `using` or catch variable. */
+export function isBlockOrCatchScoped(declaration) {
+    return ((getCombinedNodeFlags(declaration) & 7 /* NodeFlags.BlockScoped */) !== 0 ||
+        isCatchClauseVariableDeclarationOrBindingElement(declaration));
+}
+export function getContainingClass(node) {
+    let current = node.parent;
+    while (current !== undefined && !isClassLike(current))
+        current = current.parent;
+    return current;
+}
+/** The constructor of a class with a body. */
+export function findConstructorDeclaration(node) {
+    const members = getMembers(node);
+    if (members === undefined)
+        return undefined;
+    for (const member of members.nodes)
+        if (member.kind === 177 /* SyntaxKind.Constructor */ && !nodeIsMissing(getBody(member)))
+            return member;
+    return undefined;
+}
+/**
+ * The nearest function, class member, namespace, enum or source file that determines `this`
+ * for `node`; arrow functions count if `includeArrowFunctions`.
+ */
+export function getThisContainer(node, includeArrowFunctions, includeClassComputedPropertyName) {
+    let current = node;
+    for (;;) {
+        const parent = current.parent;
+        if (parent === undefined)
+            throw new Error('nil parent in getThisContainer');
+        current = parent;
+        switch (current.kind) {
+            case 168 /* 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))
+                    current = current.parent.parent;
+                else if (isClassElement(current.parent))
+                    current = current.parent;
+                break;
+            case 220 /* 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 */:
+                return current;
+        }
+    }
+}
+/** Whether `node` is outside any function, class member or namespace. */
+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 */) &&
+            getName(parent) === current)
+            current = parent;
+    }
+    return getThisContainer(current, true, false).kind === 307 /* 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 */:
+            return getName(parent) === node;
+        case 167 /* SyntaxKind.QualifiedName */:
+            return parent.right === node;
+        case 209 /* SyntaxKind.BindingElement */:
+        case 277 /* 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 */:
+            return true;
+    }
+    return false;
+}
+export function isPartOfTypeQuery(node) {
+    let current = node;
+    while (current.kind === 167 /* SyntaxKind.QualifiedName */ || current.kind === 79 /* SyntaxKind.Identifier */)
+        current = current.parent;
+    return current.kind === 187 /* 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 instanceof VariableStatement) {
+            const list = node.declarationList;
+            if ((getCombinedNodeFlags(list) & 7 /* NodeFlags.BlockScoped */) !== 0)
+                return true;
+            for (const declaration of list.declarations.nodes)
+                if (getInitializer(declaration) !== undefined)
+                    return true;
+            return false;
+        }
+        return true;
+    }
+    return (node.kind === 264 /* SyntaxKind.ClassDeclaration */ ||
+        node.kind === 267 /* SyntaxKind.EnumDeclaration */ ||
+        node.kind === 268 /* 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 */:
+            return isExternalModule(parent);
+        case 269 /* SyntaxKind.ModuleBlock */: {
+            const grandParent = parent.parent;
+            return (grandParent instanceof ModuleDeclaration &&
+                isAmbientModuleDeclaration(grandParent) &&
+                grandParent.parent.kind === 307 /* SyntaxKind.SourceFile */ &&
+                !isExternalModule(grandParent.parent));
+        }
+    }
+    return false;
+}
+function isAmbientModuleDeclaration(node) {
+    return node.name.kind === 10 /* SyntaxKind.StringLiteral */ || node.keyword === 162 /* SyntaxKind.GlobalKeyword */;
+}
+export function moduleExportNameIsDefault(node) {
+    return getText(node) === "default" /* InternalSymbolName.Default */;
+}
+export function getDeclarationOfKind(symbol, kind) {
+    for (const declaration of symbol.declarations)
+        if (declaration.kind === kind)
+            return declaration;
+    return undefined;
+}
+/** The name of a symbol, with `#name` for private class members. */
+export function symbolName(symbol) {
+    const declaration = symbol.valueDeclaration;
+    if (declaration !== undefined && isPrivateIdentifierClassElementDeclaration(declaration))
+        return getText(getName(declaration));
+    return symbol.name;
+}
+/** Whether a namespace declaration has a runtime value. Parents of `node` must be set. */
+/**
+ * `names` holds the statements of the blocks searched for the targets of `export { x }` (`forAliasTarget`)
+ * by name; a caller that asks for the states of many modules of a file passes the same one.
+ */
+export function getModuleInstanceState(node, names = new StatementsByName()) {
+    return new ModuleInstanceStateComputer(names).ofModule(node, []);
+}
+/**
+ * The statements of blocks (a block, module block or source file) by the names they declare, in
+ * order: a declaration by its name if that is an identifier, a variable statement by the identifier
+ * names of its declarations. Built for each block the first time it is searched:
+ * scanning the statements for each name made `export { x as default }` in each of the 1,671
+ * namespaces of lucide-react's dynamic.d.ts compare against all 8,600 statements of the file.
+ */
+export class StatementsByName {
+    blocks = new Map();
+    /** The statements of `block` that declare `name`. */
+    get(block, name) {
+        let byName = this.blocks.get(block);
+        if (byName === undefined) {
+            byName = new Map();
+            for (const statement of getStatements(block).nodes) {
+                const declarationName = getName(statement);
+                if (declarationName !== undefined) {
+                    if (declarationName.kind === 79 /* SyntaxKind.Identifier */)
+                        addStatementByName(byName, getText(declarationName), statement);
+                }
+                else if (statement instanceof VariableStatement) {
+                    for (const declaration of statement.declarationList.declarations.nodes) {
+                        const name = getName(declaration);
+                        if (name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */)
+                            addStatementByName(byName, getText(name), statement);
+                    }
+                }
+            }
+            this.blocks.set(block, byName);
+        }
+        return byName.get(name) ?? noStatements;
+    }
+}
+const noStatements = [];
+function addStatementByName(byName, name, statement) {
+    const statements = byName.get(name);
+    if (statements === undefined)
+        byName.set(name, [statement]);
+    // A variable statement declaring a name twice is listed once.
+    else if (statements[statements.length - 1] !== statement)
+        statements.push(statement);
+}
+class ModuleInstanceStateComputer extends NodeVisitor {
+    names;
+    visited;
+    // The module block whose children `visitNode` is folding into `blockState`.
+    blockAncestors;
+    blockState;
+    constructor(names) {
+        super();
+        this.names = names;
+        this.visited = new Map();
+        this.blockAncestors = [];
+        this.blockState = 1 /* ModuleInstanceState.NonInstantiated */;
+    }
+    ofModule(node, ancestors) {
+        const body = node.body;
+        return body === undefined ? 2 /* ModuleInstanceState.Instantiated */ : this.cached(body, withAncestor(ancestors, node));
+    }
+    cached(node, ancestors) {
+        const cached = this.visited.get(node);
+        if (cached !== undefined)
+            return cached !== 0 /* ModuleInstanceState.Unknown */ ? cached : 1 /* ModuleInstanceState.NonInstantiated */;
+        this.visited.set(node, 0 /* ModuleInstanceState.Unknown */);
+        const result = this.worker(node, ancestors);
+        this.visited.set(node, result);
+        return result;
+    }
+    worker(node, ancestors) {
+        switch (node.kind) {
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+                return 1 /* ModuleInstanceState.NonInstantiated */;
+            case 267 /* SyntaxKind.EnumDeclaration */:
+                if (isEnumConst(node))
+                    return 3 /* ModuleInstanceState.ConstEnumOnly */;
+                break;
+            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 346 /* SyntaxKind.JSImportDeclaration */:
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+                if (!hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
+                    return 1 /* ModuleInstanceState.NonInstantiated */;
+                break;
+            case 279 /* SyntaxKind.ExportDeclaration */: {
+                const exportClause = node.exportClause;
+                if (node.moduleSpecifier === undefined &&
+                    exportClause !== undefined &&
+                    exportClause.kind === 280 /* SyntaxKind.NamedExports */) {
+                    let state = 1 /* ModuleInstanceState.NonInstantiated */;
+                    const specifierAncestors = withAncestor(withAncestor(ancestors, node), exportClause);
+                    for (const specifier of getElements(exportClause).nodes) {
+                        const specifierState = this.forAliasTarget(specifier, specifierAncestors);
+                        if (specifierState > state)
+                            state = specifierState;
+                        if (state === 2 /* ModuleInstanceState.Instantiated */)
+                            return state;
+                    }
+                    return state;
+                }
+                break;
+            }
+            case 269 /* SyntaxKind.ModuleBlock */: {
+                const saveAncestors = this.blockAncestors;
+                const saveState = this.blockState;
+                this.blockAncestors = withAncestor(ancestors, node);
+                this.blockState = 1 /* ModuleInstanceState.NonInstantiated */;
+                node.forEachChild(this);
+                const state = this.blockState;
+                this.blockAncestors = saveAncestors;
+                this.blockState = saveState;
+                return state;
+            }
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+                return this.ofModule(node, ancestors);
+        }
+        return 2 /* ModuleInstanceState.Instantiated */;
+    }
+    visitNode(node) {
+        const childState = this.cached(node, this.blockAncestors);
+        switch (childState) {
+            case 1 /* ModuleInstanceState.NonInstantiated */:
+                return false;
+            case 3 /* ModuleInstanceState.ConstEnumOnly */:
+                this.blockState = 3 /* ModuleInstanceState.ConstEnumOnly */;
+                return false;
+            case 2 /* ModuleInstanceState.Instantiated */:
+                this.blockState = 2 /* ModuleInstanceState.Instantiated */;
+                return true;
+        }
+        throw new Error('Unhandled case in getModuleInstanceStateWorker');
+    }
+    forAliasTarget(specifier, ancestors) {
+        const propertyName = getPropertyName(specifier);
+        const name = propertyName !== undefined ? propertyName : getName(specifier);
+        // `export { "x" }` is invalid; assume a value.
+        if (name.kind !== 79 /* SyntaxKind.Identifier */)
+            return 2 /* ModuleInstanceState.Instantiated */;
+        const text = getText(name);
+        let remaining = ancestors.length;
+        let p = specifier;
+        for (;;) {
+            if (remaining === 0)
+                p = p.parent;
+            else
+                p = ancestors[--remaining];
+            if (p === undefined)
+                break;
+            if (p.kind !== 242 /* SyntaxKind.Block */ && p.kind !== 269 /* SyntaxKind.ModuleBlock */ && p.kind !== 307 /* SyntaxKind.SourceFile */)
+                continue;
+            let found = 0 /* ModuleInstanceState.Unknown */;
+            const statementsAncestors = ancestors.slice(0, remaining);
+            statementsAncestors.push(p);
+            for (const statement of this.names.get(p, text)) {
+                const state = this.cached(statement, statementsAncestors);
+                if (found === 0 /* ModuleInstanceState.Unknown */ || state > found)
+                    found = state;
+                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 */)
+                    found = 2 /* ModuleInstanceState.Instantiated */;
+            }
+            if (found !== 0 /* ModuleInstanceState.Unknown */)
+                return found;
+        }
+        // Not found: it could be a value.
+        return 2 /* ModuleInstanceState.Instantiated */;
+    }
+}
+function withAncestor(ancestors, node) {
+    const result = ancestors.slice();
+    result.push(node);
+    return result;
+}
+// Text and error ranges
+/** Source text of `node` without leading trivia. */
+export function getSourceTextOfNode(file, node) {
+    if (nodeIsMissing(node))
+        return '';
+    return file.text.substring(skipTrivia(file.text, node.pos), node.end);
+}
+/** A declaration name for messages: its source text, or `(Missing)`. */
+export function declarationNameToString(file, name) {
+    if (name === undefined || name.pos === name.end)
+        return '(Missing)';
+    return getTextOfNode(file, name);
+}
+function getTextOfNode(file, node) {
+    const text = getSourceTextOfNode(file, node);
+    if ((node.flags & 268435456 /* NodeFlags.ReparserTransformedLiteral */) !== 0 && node.kind === 79 /* SyntaxKind.Identifier */)
+        return getText(node);
+    return text;
+}
+/** A text range, as `[pos, end)`. */
+export class TextRange {
+    pos;
+    end;
+    constructor(pos, end) {
+        this.pos = pos;
+        this.end = end;
+    }
+}
+let rangeScanner;
+let rangeScannerFile;
+/** Forgets the file the range scanner last visited. */
+export function forgetRangeScannerFile() {
+    rangeScanner = undefined;
+    rangeScannerFile = undefined;
+}
+function scannerAt(file, pos) {
+    let scanner = rangeScanner;
+    if (scanner === undefined) {
+        scanner = new Scanner();
+        rangeScanner = scanner;
+    }
+    if (rangeScannerFile !== file) {
+        scanner.setText(file.text);
+        scanner.setLanguageVariant(file.languageVariant);
+        rangeScannerFile = file;
+    }
+    scanner.resetTokenState(pos);
+    scanner.scan();
+    return scanner;
+}
+/** The token starting at or after `pos`. */
+export function getRangeOfTokenAtPosition(file, pos) {
+    const scanner = scannerAt(file, pos);
+    return new TextRange(scanner.getTokenStart(), scanner.getTokenEnd());
+}
+function isLineBreak(ch) {
+    return ch === 0x0a || ch === 0x0d || ch === 0x2028 || ch === 0x2029;
+}
+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 */) {
+        const lineStarts = file.lineStarts();
+        const startLine = computeLineOfPosition(lineStarts, body.pos);
+        const endLine = computeLineOfPosition(lineStarts, body.end);
+        if (startLine < endLine) {
+            // A multi-line arrow function: the span is its first line, including the line break.
+            let end = lineStarts[startLine];
+            while (end < text.length && !isLineBreak(text.charCodeAt(end)))
+                end += 1;
+            return new TextRange(pos, end);
+        }
+    }
+    return new TextRange(pos, node.end);
+}
+/** The `@satisfies` tag a reparsed `satisfies` expression came from. */
+function findOriginatingJSDocSatisfiesTag(file, node) {
+    const targetType = node.type;
+    if ((targetType.flags & 8 /* NodeFlags.Reparsed */) === 0)
+        return undefined;
+    for (let current = node.parent; current !== undefined; current = current.parent) {
+        if ((current.flags & 2097152 /* NodeFlags.HasJSDoc */) === 0)
+            continue;
+        let first;
+        for (const jsDoc of getJSDoc(file, current)) {
+            if (!(jsDoc instanceof JSDoc))
+                continue;
+            const tagList = jsDoc.tags;
+            if (tagList === undefined)
+                continue;
+            const tags = tagList.nodes;
+            for (let i = 0; i < tags.length; i++) {
+                const tag = tags[i];
+                if (tag instanceof JSDocSatisfiesTag) {
+                    if (first === undefined)
+                        first = tag;
+                    const type = getType(tag.typeExpression);
+                    if (type !== undefined && type.pos === targetType.pos && type.end === targetType.end)
+                        return tag;
+                }
+            }
+        }
+        return first;
+    }
+    return undefined;
+}
+/** Where to report an error on `node`: usually its name, or its first token. */
+export function getErrorRangeForNode(file, node) {
+    const text = file.text;
+    let errorNode = node;
+    switch (node.kind) {
+        case 307 /* 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 */:
+            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 */:
+            errorNode = getNameOfDeclaration(node);
+            break;
+        case 232 /* SyntaxKind.ClassExpression */:
+            errorNode = getName(node);
+            break;
+        case 220 /* SyntaxKind.ArrowFunction */:
+            return getErrorRangeForArrowFunction(file, node);
+        case 297 /* SyntaxKind.CaseClause */:
+        case 298 /* 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 */:
+            return getRangeOfTokenAtPosition(file, skipTrivia(text, node.pos));
+        case 239 /* 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 */: {
+            if ((node.flags & 8 /* NodeFlags.Reparsed */) !== 0)
+                break;
+            const scanner = scannerAt(file, node.pos);
+            const start = scanner.getTokenStart();
+            for (;;) {
+                const token = scanner.getToken();
+                if (token === 136 /* SyntaxKind.ConstructorKeyword */ ||
+                    token === 10 /* SyntaxKind.StringLiteral */ ||
+                    token === 1 /* SyntaxKind.EndOfFile */)
+                    break;
+                scanner.scan();
+            }
+            return new TextRange(start, scanner.getTokenEnd());
+        }
+    }
+    // Without a better node, use the first token of the construct.
+    if (errorNode === undefined)
+        return getRangeOfTokenAtPosition(file, node.pos);
+    let pos = errorNode.pos;
+    if (!nodeIsMissing(errorNode) && errorNode.kind !== 11 /* SyntaxKind.JsxText */)
+        pos = skipTrivia(text, pos);
+    return new TextRange(pos, errorNode.end);
+}