tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/reparser.js

@@ -0,0 +1,1323 @@
+// Reparsing of JSDoc in JavaScript files into TypeScript syntax, a port of tsgo's parser/reparser.go.
+//
+// Hosted tags (`@type`, `@param`, `@returns`, …) add children to the node they document; unhosted
+// tags (`@typedef`, `@callback`, `@import`, `@overload`) produce declarations in `Parser.reparseList`.
+// Reparsed nodes are flagged `NodeFlags.Reparsed`.
+//
+// Fields of `instanceof`-narrowed nodes are read through `as` casts: scriptc reads them
+// statically, but reads fields of a narrowed value dynamically.
+import { ArrayTypeNode, ArrowFunction, AsExpression, BinaryExpression, CallSignatureDeclaration, ClassDeclaration, ClassExpression, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ElementAccessExpression, ExportAssignment, ExpressionStatement, ExpressionWithTypeArguments, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, ImportDeclaration, IndexSignatureDeclaration, JSDoc, JSDocAugmentsTag, JSDocCallbackTag, JSDocImplementsTag, JSDocImportTag, JSDocOverloadTag, JSDocParameterOrPropertyTag, JSDocSatisfiesTag, JSDocSignature, JSDocTemplateTag, JSDocThisTag, JSDocTypeExpression, JSDocTypeLiteral, JSDocTypedefTag, JSDocVariadicType, JSDocOptionalType, KeywordTypeNode, MethodDeclaration, MethodSignatureDeclaration, ModifierList, ModuleBlock, ModuleDeclaration, NodeList, NodeVisitor, NumericLiteral, ParameterDeclaration, ParenthesizedExpression, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, StringLiteral, Token, TypeAliasDeclaration, TypeLiteralNode, TypeParameterDeclaration, VariableDeclaration, VariableStatement, getComment, getModifiers, getName, getParameters, getText, getType, getTypeExpression, getTypeParameters, } from './ast.js';
+import { isAssignmentOperator, isFunctionLike, isInJSFile, isLeftHandSideExpression, isStringLiteralLike, } from './ast-utilities.js';
+import { isIdentifierPart, isIdentifierStart } from './character-codes.js';
+/** Sets the parent of every node in a subtree. */
+class ParentInChildrenSetter extends NodeVisitor {
+    parent = undefined;
+    visitNode(node) {
+        node.parent = this.parent;
+        const saveParent = this.parent;
+        this.parent = node;
+        node.forEachChild(this);
+        this.parent = saveParent;
+        return false;
+    }
+}
+export class Reparser {
+    p;
+    parentSetter;
+    constructor(p) {
+        this.p = p;
+        this.parentSetter = new ParentInChildrenSetter();
+    }
+    // Node helpers
+    finishReparsedNode(node, locationNode) {
+        node.flags = this.p.contextFlags | 8 /* NodeFlags.Reparsed */;
+        node.pos = locationNode.pos;
+        node.end = locationNode.end;
+        this.p.overrideParentInImmediateChildren(node);
+        return node;
+    }
+    finishMutatedNode(node) {
+        this.p.overrideParentInImmediateChildren(node);
+        return node;
+    }
+    /** Sets parents in a cloned subtree and flags its root as reparsed. */
+    finishClone(clone) {
+        const setter = this.parentSetter;
+        setter.parent = clone;
+        clone.forEachChild(setter);
+        setter.parent = undefined;
+        clone.flags |= 8 /* NodeFlags.Reparsed */;
+        return clone;
+    }
+    /** A reparsed deep clone, not recorded in `reparsedClones`. */
+    deepCloneReparse(node) {
+        return this.finishClone(node.deepClone());
+    }
+    /**
+     * A reparsed deep clone, recorded in `reparsedClones`: the binder attaches symbols to reparsed nodes,
+     * and the list maps JSDoc nodes to them.
+     */
+    addDeepCloneReparse(node) {
+        const clone = this.deepCloneReparse(node);
+        this.p.reparsedClones.push(clone);
+        return clone;
+    }
+    addDeepCloneReparseIdentifier(node) {
+        const clone = node.copy();
+        this.finishClone(clone);
+        this.p.reparsedClones.push(clone);
+        return clone;
+    }
+    addTransformedReparse(newNode, old) {
+        this.finishReparsedNode(newNode, old);
+        newNode.flags |= 268435456 /* NodeFlags.ReparserTransformedLiteral */;
+        this.p.reparsedClones.push(newNode);
+        return newNode;
+    }
+    /** A deep clone of modifiers, without reparsed flags or parents. */
+    cloneModifiers(modifiers) {
+        if (modifiers === undefined)
+            return undefined;
+        const nodes = [];
+        for (const m of modifiers.nodes)
+            nodes.push(m.deepClone());
+        return new ModifierList(modifiers.pos, modifiers.end, nodes, modifiers.modifierFlags);
+    }
+    /** Reports an invalid identifier name, at the preceding character if it's missing. */
+    checkNonIdentifierName(name) {
+        if (name instanceof Identifier && !isValidIdentifier(name.text)) {
+            if (name.end - name.pos === 0)
+                this.p.parseErrorAt(name.pos - 1, name.pos, 1 /* Diagnostics.Identifier_expected */);
+            else
+                this.p.parseErrorAt(name.pos, name.end, 1 /* Diagnostics.Identifier_expected */);
+        }
+        return name;
+    }
+    // Tags
+    reparseTags(parent, jsDoc) {
+        let index = 0;
+        for (const doc of jsDoc) {
+            const isLast = index === jsDoc.length - 1;
+            index++;
+            const j = asJSDoc(doc);
+            if (j === undefined || j.tags === undefined)
+                continue;
+            for (const tag of j.tags.nodes) {
+                this.reparseUnhosted(tag, parent, j);
+                if (isLast)
+                    this.reparseHosted(tag, parent, j);
+            }
+        }
+        return true;
+    }
+    reparseUnhosted(tag, parent, jsDoc) {
+        const p = this.p;
+        if (tag instanceof JSDocTypedefTag) {
+            const typeExpression = tag.typeExpression;
+            if (typeExpression === undefined)
+                return false;
+            const fullName = tag.name;
+            const modifiers = fullName instanceof ModuleDeclaration ? this.createExportModifier(tag) : undefined;
+            const name = this.cloneTypeAliasName(this.checkNonIdentifierName(this.getInnermostNameOfJSDocNamespace(fullName)));
+            const typeParameters = this.gatherTypeParameters(jsDoc, true);
+            let type;
+            if (typeExpression instanceof JSDocTypeExpression)
+                type = this.addDeepCloneReparse(typeExpression.type);
+            else if (typeExpression instanceof JSDocTypeLiteral)
+                type = this.reparseJSDocTypeLiteral(typeExpression);
+            else
+                throw new Error('typedef tag type expression should be a name reference or a type expression');
+            const typeAlias = new TypeAliasDeclaration(345 /* SyntaxKind.JSTypeAliasDeclaration */, modifiers, name, typeParameters, type);
+            this.finishReparsedNode(typeAlias, tag);
+            this.attachReparsedJSDoc(typeAlias, jsDoc);
+            p.reparseList.push(this.wrapInJSDocNamespace(fullName, typeAlias, false));
+            return true;
+        }
+        if (tag instanceof JSDocCallbackTag) {
+            const fullName = tag.name;
+            const modifiers = fullName instanceof ModuleDeclaration ? this.createExportModifier(tag) : undefined;
+            const functionType = this.reparseJSDocSignature(tag.typeExpression, tag, jsDoc, tag, undefined);
+            const name = this.cloneTypeAliasName(this.getInnermostNameOfJSDocNamespace(fullName));
+            const typeParameters = this.gatherTypeParameters(jsDoc, true);
+            const typeAlias = new TypeAliasDeclaration(345 /* SyntaxKind.JSTypeAliasDeclaration */, modifiers, name, typeParameters, functionType);
+            this.finishReparsedNode(typeAlias, tag);
+            this.attachReparsedJSDoc(typeAlias, jsDoc);
+            p.reparseList.push(this.wrapInJSDocNamespace(fullName, typeAlias, false));
+            return true;
+        }
+        if (tag instanceof JSDocImportTag) {
+            const tagImportClause = tag.importClause;
+            if (tagImportClause === undefined)
+                return false;
+            const importClause = tagImportClause.copy();
+            this.finishClone(importClause);
+            p.reparsedClones.push(importClause);
+            importClause.phaseModifier = 156 /* SyntaxKind.TypeKeyword */;
+            const moduleSpecifier = this.addDeepCloneReparse(tag.moduleSpecifier);
+            const tagAttributes = tag.attributes;
+            let attributes;
+            if (tagAttributes !== undefined) {
+                const copy = tagAttributes.copy();
+                this.finishClone(copy);
+                p.reparsedClones.push(copy);
+                attributes = copy;
+            }
+            const importDeclaration = new ImportDeclaration(346 /* SyntaxKind.JSImportDeclaration */, undefined, importClause, moduleSpecifier, attributes);
+            this.finishReparsedNode(importDeclaration, tag);
+            p.reparseList.push(importDeclaration);
+            return true;
+        }
+        if (tag instanceof JSDocOverloadTag) {
+            // Overload signatures only for functions, methods and constructors outside object literals.
+            if ((parent.kind === 263 /* SyntaxKind.FunctionDeclaration */ ||
+                parent.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
+                parent.kind === 177 /* SyntaxKind.Constructor */) &&
+                !p.inObjectLiteralMembers())
+                p.reparseList.push(this.reparseJSDocSignature(tag.typeExpression, parent, jsDoc, tag, getModifiers(parent)));
+            return true;
+        }
+        return false;
+    }
+    attachReparsedJSDoc(node, jsDoc) {
+        const docs = [];
+        docs.push(jsDoc);
+        this.p.setJSDoc(node, docs);
+        node.flags |= 2097152 /* NodeFlags.HasJSDoc */;
+        return true;
+    }
+    cloneTypeAliasName(name) {
+        if (!(name instanceof Identifier))
+            throw new Error('Expected an identifier for a JSDoc type alias name');
+        return this.addDeepCloneReparseIdentifier(name);
+    }
+    reparseJSDocSignature(jsSignature, fun, jsDoc, tag, modifiers) {
+        const p = this.p;
+        const clonedModifiers = this.cloneModifiers(modifiers);
+        // The name, then the type parameters, then the parameters, as tsgo creates them.
+        let functionName;
+        let methodName;
+        if (fun instanceof FunctionDeclaration) {
+            const name = fun.name;
+            if (name !== undefined) {
+                this.checkNonIdentifierName(name);
+                functionName = name.copy();
+                this.finishClone(functionName);
+            }
+        }
+        else if (fun instanceof MethodDeclaration) {
+            methodName = this.deepCloneReparse(this.checkNonIdentifierName(fun.name));
+        }
+        else if (fun.kind !== 177 /* SyntaxKind.Constructor */ && fun.kind !== 331 /* SyntaxKind.JSDocCallbackTag */) {
+            throw new Error('Unexpected kind ' + fun.kind);
+        }
+        const typeParameters = tag.kind !== 331 /* SyntaxKind.JSDocCallbackTag */ ? this.gatherTypeParameters(jsDoc, false) : undefined;
+        const parameters = [];
+        const signatureParameters = jsSignature instanceof JSDocSignature ? jsSignature.parameters : undefined;
+        if (signatureParameters !== undefined) {
+            const params = signatureParameters.nodes;
+            for (let pi = 0; pi < params.length; pi++) {
+                const param = params[pi];
+                let parameter;
+                if (param instanceof JSDocThisTag) {
+                    const thisIdent = new Identifier('this');
+                    thisIdent.pos = param.pos;
+                    thisIdent.end = param.end;
+                    thisIdent.flags = p.contextFlags | 8 /* NodeFlags.Reparsed */;
+                    const type = this.addDeepCloneReparse(getType(param.typeExpression));
+                    parameter = new ParameterDeclaration(undefined, undefined, thisIdent, undefined, type, undefined);
+                }
+                else if (param instanceof JSDocParameterOrPropertyTag) {
+                    // Sub-properties like `@param x.y` describe a parameter's properties, not parameters.
+                    if (param.name instanceof QualifiedName)
+                        continue;
+                    let dotDotDotToken;
+                    let paramType;
+                    const typeExpression = param.typeExpression;
+                    if (typeExpression !== undefined) {
+                        const type = getType(typeExpression);
+                        if (type instanceof JSDocVariadicType) {
+                            dotDotDotToken = new Token(25 /* SyntaxKind.DotDotDotToken */);
+                            dotDotDotToken.pos = param.pos;
+                            dotDotDotToken.end = param.end;
+                            dotDotDotToken.flags = p.contextFlags | 8 /* NodeFlags.Reparsed */;
+                            paramType = this.reparseJSDocTypeLiteral(type.type);
+                        }
+                        else {
+                            paramType = this.reparseJSDocTypeLiteral(type);
+                        }
+                    }
+                    let name = param.name;
+                    if (name instanceof Identifier && !isValidIdentifier(name.text)) {
+                        // Replace invalid characters with `_`, or use `_N` for an empty name, for a valid parameter name.
+                        name = this.addTransformedReparse(new Identifier(sanitizeIdentifier(name.text, pi)), name);
+                    }
+                    else {
+                        name = this.addDeepCloneReparse(name);
+                    }
+                    parameter = new ParameterDeclaration(undefined, dotDotDotToken, name, this.makeQuestionIfOptional(param), paramType, undefined);
+                }
+                else {
+                    continue;
+                }
+                this.finishReparsedNode(parameter, param);
+                parameters.push(parameter);
+                this.reparseJSDocComment(parameter, param);
+            }
+        }
+        const parameterList = new NodeList(signatureParameters !== undefined ? signatureParameters.pos : -1, signatureParameters !== undefined ? signatureParameters.end : -1, parameters);
+        let returnType;
+        const returnTag = getType(jsSignature);
+        if (returnTag !== undefined) {
+            const returnTypeExpression = getTypeExpression(returnTag);
+            if (returnTypeExpression !== undefined)
+                returnType = this.addDeepCloneReparse(getType(returnTypeExpression));
+        }
+        let signature;
+        if (fun instanceof FunctionDeclaration)
+            signature = new FunctionDeclaration(clonedModifiers, undefined, functionName, typeParameters, parameterList, returnType, undefined, undefined);
+        else if (fun instanceof MethodDeclaration)
+            signature = new MethodDeclaration(clonedModifiers, undefined, methodName, undefined, typeParameters, parameterList, returnType, undefined, undefined);
+        else if (fun instanceof ConstructorDeclaration)
+            signature = new ConstructorDeclaration(clonedModifiers, typeParameters, parameterList, returnType, undefined, undefined);
+        else
+            signature = new FunctionTypeNode(undefined, parameterList, returnType !== undefined ? returnType : new KeywordTypeNode(132 /* SyntaxKind.AnyKeyword */));
+        const location = tag instanceof JSDocOverloadTag ? tag.tagName : jsSignature;
+        this.finishReparsedNode(signature, location);
+        return signature;
+    }
+    reparseJSDocTypeLiteral(type) {
+        if (type instanceof JSDocTypeLiteral) {
+            const properties = [];
+            const tags = type.jsdocPropertyTags;
+            if (tags !== undefined)
+                for (const tag of tags) {
+                    const prop = asParameterOrPropertyTag(tag);
+                    if (prop !== undefined)
+                        properties.push(this.reparseJSDocProperty(prop));
+                }
+            let result = new TypeLiteralNode(this.p.newNodeList(type.pos, type.end, properties));
+            if (type.isArrayType) {
+                this.finishReparsedNode(result, type);
+                result = new ArrayTypeNode(result);
+            }
+            this.finishReparsedNode(result, type);
+            return result;
+        }
+        return this.addDeepCloneReparse(type);
+    }
+    reparseJSDocProperty(prop) {
+        let name = prop.name;
+        if (name instanceof QualifiedName)
+            name = name.right;
+        if (name instanceof Identifier && !isValidIdentifier(name.text))
+            name = this.addTransformedReparse(new StringLiteral(name.text, 0 /* TokenFlags.None */), name);
+        else
+            name = this.addDeepCloneReparse(name);
+        const questionToken = this.makeQuestionIfOptional(prop);
+        const propertyType = prop.typeExpression !== undefined ? this.reparseJSDocTypeLiteral(getType(prop.typeExpression)) : undefined;
+        const property = new PropertySignatureDeclaration(undefined, name, questionToken, propertyType, undefined);
+        this.finishReparsedNode(property, prop);
+        this.reparseJSDocComment(property, prop);
+        return property;
+    }
+    /** Copies a tag's comment to a JSDoc node for its reparsed node. */
+    reparseJSDocComment(node, tag) {
+        const comment = getComment(tag);
+        if (comment === undefined)
+            return false;
+        const nodes = [];
+        for (const c of comment.nodes)
+            nodes.push(this.deepCloneReparse(c));
+        const propJSDoc = new JSDoc(new NodeList(comment.pos, comment.end, nodes), undefined);
+        this.finishReparsedNode(propJSDoc, tag);
+        propJSDoc.parent = node;
+        const docs = [];
+        docs.push(propJSDoc);
+        this.p.setJSDoc(node, docs);
+        node.flags |= 2097152 /* NodeFlags.HasJSDoc */;
+        return true;
+    }
+    /** The type parameters of the `@template` tags; for non-typedefs, none if the comment has a @typedef or @callback. */
+    gatherTypeParameters(j, typedefOrCallback) {
+        const typeParameters = [];
+        let pos = -1;
+        let endPos = -1;
+        let firstTemplate = true;
+        const tags = j.tags;
+        if (tags === undefined)
+            return undefined;
+        for (const tag of tags.nodes) {
+            // With a @typedef or @callback, @template declares the defined type's type parameters.
+            if (!typedefOrCallback && (tag.kind === 338 /* SyntaxKind.JSDocTypedefTag */ || tag.kind === 331 /* SyntaxKind.JSDocCallbackTag */))
+                return undefined;
+            if (!(tag instanceof JSDocTemplateTag))
+                continue;
+            if (firstTemplate) {
+                pos = tag.pos;
+                firstTemplate = false;
+            }
+            endPos = tag.end;
+            const constraint = tag.constraint;
+            let firstTypeParameter = true;
+            for (const tp of tag.typeParameters.nodes) {
+                let reparse;
+                if (constraint !== undefined && firstTypeParameter && tp instanceof TypeParameterDeclaration) {
+                    const modifiers = this.cloneModifiers(tp.modifiers);
+                    this.checkNonIdentifierName(tp.name);
+                    const name = this.addDeepCloneReparseIdentifier(tp.name);
+                    const constraintType = this.addDeepCloneReparse(getType(constraint));
+                    const tpDefault = tp.defaultType;
+                    const defaultType = tpDefault !== undefined ? this.addDeepCloneReparse(tpDefault) : undefined;
+                    reparse = new TypeParameterDeclaration(modifiers, name, constraintType, undefined, defaultType);
+                    this.finishReparsedNode(reparse, tp);
+                }
+                else {
+                    reparse = this.addDeepCloneReparse(tp);
+                }
+                typeParameters.push(reparse);
+                firstTypeParameter = false;
+            }
+        }
+        return typeParameters.length === 0 ? undefined : this.p.newNodeList(pos, endPos, typeParameters);
+    }
+    reparseHosted(tag, parent, jsDoc) {
+        switch (tag.kind) {
+            case 336 /* SyntaxKind.JSDocTypeTag */:
+                return this.reparseTypeTag(tag, parent);
+            case 342 /* SyntaxKind.JSDocSatisfiesTag */:
+                if (tag instanceof JSDocSatisfiesTag)
+                    this.reparseSatisfiesTag(tag, parent);
+                return true;
+            case 337 /* SyntaxKind.JSDocTemplateTag */: {
+                const fun = getFunctionLikeHost(parent);
+                if (fun !== undefined) {
+                    if (getTypeParameters(fun) === undefined && getFullSignature(fun) === undefined) {
+                        setTypeParameters(fun, this.gatherTypeParameters(jsDoc, false));
+                        this.finishMutatedNode(fun);
+                    }
+                }
+                else if (parent.kind === 264 /* SyntaxKind.ClassDeclaration */ || parent.kind === 232 /* SyntaxKind.ClassExpression */) {
+                    if (getClassTypeParameters(parent) === undefined) {
+                        setClassTypeParameters(parent, this.gatherTypeParameters(jsDoc, false));
+                        this.finishMutatedNode(parent);
+                    }
+                }
+                return true;
+            }
+            case 333 /* SyntaxKind.JSDocParameterTag */: {
+                const fun = getFunctionLikeHost(parent);
+                if (fun !== undefined && getFullSignature(fun) === undefined && tag instanceof JSDocParameterOrPropertyTag) {
+                    const param = findMatchingParameter(fun, tag, jsDoc);
+                    if (param !== undefined) {
+                        const typeExpression = tag.typeExpression;
+                        if (param.type === undefined && typeExpression !== undefined)
+                            param.type = this.reparseJSDocTypeLiteral(getType(typeExpression));
+                        if (param.questionToken === undefined) {
+                            const question = this.makeQuestionIfOptional(tag);
+                            if (question !== undefined)
+                                param.questionToken = question;
+                        }
+                        this.finishMutatedNode(param);
+                    }
+                }
+                return true;
+            }
+            case 335 /* SyntaxKind.JSDocThisTag */: {
+                const fun = getFunctionLikeHost(parent);
+                if (fun !== undefined && tag instanceof JSDocThisTag) {
+                    const parameters = getParameters(fun);
+                    const params = parameters !== undefined ? parameters.nodes : [];
+                    const firstName = params.length > 0 ? getName(params[0]) : undefined;
+                    if (params.length === 0 ||
+                        (firstName !== undefined &&
+                            firstName.kind !== 109 /* SyntaxKind.ThisKeyword */ &&
+                            !(firstName instanceof Identifier && firstName.text === 'this'))) {
+                        // tsgo gives the `this` name no location.
+                        const thisParam = new ParameterDeclaration(undefined, undefined, new Identifier('this'), undefined, undefined, undefined);
+                        thisParam.type = this.addDeepCloneReparse(getType(tag.typeExpression));
+                        this.finishReparsedNode(thisParam, tag.tagName);
+                        const newParams = [thisParam];
+                        for (const param of params)
+                            newParams.push(param);
+                        setParameters(fun, this.p.newNodeList(parameters !== undefined ? parameters.pos : -1, parameters !== undefined ? parameters.end : -1, newParams));
+                        this.finishMutatedNode(fun);
+                    }
+                }
+                return true;
+            }
+            case 334 /* SyntaxKind.JSDocReturnTag */: {
+                const fun = getFunctionLikeHost(parent);
+                if (fun !== undefined && getFullSignature(fun) === undefined) {
+                    const typeExpression = getTypeExpression(tag);
+                    if (getType(fun) === undefined && typeExpression !== undefined) {
+                        setType(fun, this.addDeepCloneReparse(getType(typeExpression)));
+                        this.finishMutatedNode(fun);
+                    }
+                }
+                return true;
+            }
+            case 329 /* SyntaxKind.JSDocReadonlyTag */:
+            case 327 /* SyntaxKind.JSDocPrivateTag */:
+            case 326 /* SyntaxKind.JSDocPublicTag */:
+            case 328 /* SyntaxKind.JSDocProtectedTag */:
+            case 330 /* SyntaxKind.JSDocOverrideTag */:
+                return this.reparseModifierTag(tag, parent);
+            case 324 /* SyntaxKind.JSDocImplementsTag */:
+                if (tag instanceof JSDocImplementsTag)
+                    this.reparseImplementsTag(tag, parent);
+                return true;
+            case 323 /* SyntaxKind.JSDocAugmentsTag */:
+                if (tag instanceof JSDocAugmentsTag)
+                    this.reparseAugmentsTag(tag, parent);
+                return true;
+        }
+        return false;
+    }
+    reparseTypeTag(tag, parent) {
+        const typeExpression = getTypeExpression(tag);
+        switch (parent.kind) {
+            case 244 /* SyntaxKind.VariableStatement */:
+                if (parent instanceof VariableStatement)
+                    for (const declaration of parent.declarationList.declarations.nodes)
+                        if (declaration instanceof VariableDeclaration &&
+                            declaration.type === undefined &&
+                            typeExpression !== undefined) {
+                            declaration.type = this.addDeepCloneReparse(getType(typeExpression));
+                            this.finishMutatedNode(declaration);
+                            return true;
+                        }
+                break;
+            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 278 /* SyntaxKind.ExportAssignment */:
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 303 /* SyntaxKind.PropertyAssignment */:
+            case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            case 178 /* SyntaxKind.GetAccessor */:
+                if (getType(parent) === undefined && typeExpression !== undefined) {
+                    setType(parent, this.addDeepCloneReparse(getType(typeExpression)));
+                    this.finishMutatedNode(parent);
+                    return true;
+                }
+                break;
+            case 170 /* SyntaxKind.Parameter */:
+                if (getType(parent) === undefined && typeExpression !== undefined) {
+                    setType(parent, this.reparseJSDocTypeLiteral(getType(typeExpression)));
+                    this.finishMutatedNode(parent);
+                    return true;
+                }
+                break;
+            case 245 /* SyntaxKind.ExpressionStatement */:
+                if (parent instanceof ExpressionStatement) {
+                    const bin = parent.expression;
+                    if (bin instanceof BinaryExpression && isAssignmentDeclaration(bin) && typeExpression !== undefined) {
+                        bin.type = this.addDeepCloneReparse(getType(typeExpression));
+                        this.finishMutatedNode(bin);
+                        return true;
+                    }
+                }
+                break;
+            case 254 /* SyntaxKind.ReturnStatement */:
+            case 218 /* SyntaxKind.ParenthesizedExpression */: {
+                const expression = getExpressionOfReturnOrParenthesized(parent);
+                if (expression !== undefined && typeExpression !== undefined) {
+                    setExpression(parent, this.makeNewCast(this.addDeepCloneReparse(getType(typeExpression)), expression, true));
+                    this.finishMutatedNode(parent);
+                    return true;
+                }
+                break;
+            }
+        }
+        const fun = getFunctionLikeHost(parent);
+        if (fun !== undefined) {
+            const parameters = getParameters(fun);
+            let noTypedParams = true;
+            if (parameters !== undefined)
+                for (const param of parameters.nodes)
+                    if (getType(param) !== undefined) {
+                        noTypedParams = false;
+                        break;
+                    }
+            if (getTypeParameters(fun) === undefined &&
+                getType(fun) === undefined &&
+                noTypedParams &&
+                typeExpression !== undefined) {
+                setFullSignature(fun, this.addDeepCloneReparse(getType(typeExpression)));
+                this.finishMutatedNode(fun);
+            }
+        }
+        return true;
+    }
+    reparseSatisfiesTag(tag, parent) {
+        const typeExpression = tag.typeExpression;
+        if (parent instanceof VariableStatement) {
+            for (const declaration of parent.declarationList.declarations.nodes)
+                if (declaration instanceof VariableDeclaration) {
+                    const initializer = declaration.initializer;
+                    if (initializer === undefined)
+                        continue;
+                    declaration.initializer = this.makeNewCast(this.addDeepCloneReparse(getType(typeExpression)), initializer, false);
+                    this.finishMutatedNode(declaration);
+                    break;
+                }
+        }
+        else if (parent.kind === 261 /* SyntaxKind.VariableDeclaration */ ||
+            parent.kind === 173 /* SyntaxKind.PropertyDeclaration */ ||
+            parent.kind === 303 /* SyntaxKind.PropertyAssignment */) {
+            const initializer = getInitializer(parent);
+            if (initializer !== undefined) {
+                setInitializer(parent, this.makeNewCast(this.addDeepCloneReparse(getType(typeExpression)), initializer, false));
+                this.finishMutatedNode(parent);
+            }
+        }
+        else if (parent instanceof ShorthandPropertyAssignment) {
+            const initializer = parent.objectAssignmentInitializer;
+            if (initializer !== undefined) {
+                parent.objectAssignmentInitializer = this.makeNewCast(this.addDeepCloneReparse(getType(typeExpression)), initializer, false);
+                this.finishMutatedNode(parent);
+            }
+        }
+        else if (parent.kind === 254 /* SyntaxKind.ReturnStatement */ ||
+            parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */ ||
+            parent.kind === 278 /* SyntaxKind.ExportAssignment */) {
+            const expression = getExpressionOfReturnOrParenthesized(parent);
+            if (expression !== undefined) {
+                setExpression(parent, this.makeNewCast(this.addDeepCloneReparse(getType(typeExpression)), expression, false));
+                this.finishMutatedNode(parent);
+            }
+        }
+        else if (parent instanceof ExpressionStatement) {
+            const bin = parent.expression;
+            if (bin instanceof BinaryExpression && isAssignmentDeclaration(bin)) {
+                bin.right = this.makeNewCast(this.addDeepCloneReparse(getType(typeExpression)), bin.right, false);
+                this.finishMutatedNode(bin);
+            }
+        }
+        return true;
+    }
+    reparseModifierTag(tag, parent) {
+        if (parent instanceof ExpressionStatement)
+            parent = parent.expression;
+        switch (parent.kind) {
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+                // In object literals these aren't class members: reparsed modifiers would cause spurious grammar errors.
+                if (this.p.inObjectLiteralMembers())
+                    return false;
+                break;
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 177 /* SyntaxKind.Constructor */:
+            case 227 /* SyntaxKind.BinaryExpression */:
+                break;
+            default:
+                return false;
+        }
+        let keyword = 0 /* SyntaxKind.Unknown */;
+        switch (tag.kind) {
+            case 329 /* SyntaxKind.JSDocReadonlyTag */:
+                keyword = 148 /* SyntaxKind.ReadonlyKeyword */;
+                break;
+            case 327 /* SyntaxKind.JSDocPrivateTag */:
+                keyword = 122 /* SyntaxKind.PrivateKeyword */;
+                break;
+            case 326 /* SyntaxKind.JSDocPublicTag */:
+                keyword = 124 /* SyntaxKind.PublicKeyword */;
+                break;
+            case 328 /* SyntaxKind.JSDocProtectedTag */:
+                keyword = 123 /* SyntaxKind.ProtectedKeyword */;
+                break;
+            default:
+                keyword = 164 /* SyntaxKind.OverrideKeyword */;
+        }
+        const modifier = new Token(keyword);
+        modifier.pos = tag.pos;
+        modifier.end = tag.end;
+        modifier.flags = this.p.contextFlags | 8 /* NodeFlags.Reparsed */;
+        const existing = getModifiers(parent);
+        let list;
+        if (existing === undefined) {
+            list = this.p.newModifierList(tag.pos, tag.end, [modifier]);
+        }
+        else {
+            const nodes = existing.nodes.slice();
+            nodes.push(modifier);
+            list = this.p.newModifierList(existing.pos, existing.end, nodes);
+        }
+        setModifiers(parent, list);
+        this.finishMutatedNode(parent);
+        return true;
+    }
+    reparseImplementsTag(tag, parent) {
+        if (parent.kind !== 264 /* SyntaxKind.ClassDeclaration */ && parent.kind !== 232 /* SyntaxKind.ClassExpression */)
+            return false;
+        const className = tag.className;
+        const heritageClauses = getHeritageClauses(parent);
+        if (heritageClauses !== undefined) {
+            for (const clause of heritageClauses.nodes)
+                if (clause instanceof HeritageClause && clause.token === 118 /* SyntaxKind.ImplementsKeyword */) {
+                    clause.types.nodes.push(this.addDeepCloneReparse(className));
+                    this.finishMutatedNode(clause);
+                    return true;
+                }
+        }
+        const typesList = this.p.newNodeList(className.pos, className.end, [this.addDeepCloneReparse(className)]);
+        const heritageClause = new HeritageClause(118 /* SyntaxKind.ImplementsKeyword */, typesList);
+        this.finishReparsedNode(heritageClause, className);
+        if (heritageClauses === undefined)
+            setHeritageClauses(parent, this.p.newNodeList(className.pos, className.end, [heritageClause]));
+        else
+            heritageClauses.nodes.push(heritageClause);
+        this.finishMutatedNode(parent);
+        return true;
+    }
+    reparseAugmentsTag(tag, parent) {
+        const heritageClauses = getHeritageClauses(parent);
+        if (heritageClauses === undefined)
+            return false;
+        for (const clause of heritageClauses.nodes) {
+            if (!(clause instanceof HeritageClause) || clause.token !== 95 /* SyntaxKind.ExtendsKeyword */)
+                continue;
+            if (clause.types.nodes.length !== 1)
+                return false;
+            const target = clause.types.nodes[0];
+            const source = tag.className;
+            if (target instanceof ExpressionWithTypeArguments &&
+                hasSamePropertyAccessName(target.expression, source.expression) &&
+                target.typeArguments === undefined &&
+                source.typeArguments !== undefined) {
+                const newArguments = [];
+                for (const arg of source.typeArguments.nodes)
+                    newArguments.push(this.addDeepCloneReparse(arg));
+                target.typeArguments = this.p.newNodeList(source.typeArguments.pos, source.typeArguments.end, newArguments);
+                this.finishMutatedNode(target);
+            }
+            return true;
+        }
+        return false;
+    }
+    makeQuestionIfOptional(parameter) {
+        const typeExpression = parameter.typeExpression;
+        if (parameter.isBracketed ||
+            (typeExpression !== undefined && getType(typeExpression) instanceof JSDocOptionalType)) {
+            const questionToken = new Token(57 /* SyntaxKind.QuestionToken */);
+            questionToken.pos = parameter.pos;
+            questionToken.end = parameter.end;
+            questionToken.flags = this.p.contextFlags | 8 /* NodeFlags.Reparsed */;
+            return questionToken;
+        }
+        return undefined;
+    }
+    makeNewCast(type, e, isAssertion) {
+        const cast = isAssertion ? new AsExpression(e, type) : new SatisfiesExpression(e, type);
+        this.p.finishNodeWithEnd(cast, e.pos, e.end);
+        return cast;
+    }
+    createExportModifier(locationNode) {
+        const exportModifier = new Token(94 /* SyntaxKind.ExportKeyword */);
+        exportModifier.pos = locationNode.pos;
+        exportModifier.end = locationNode.end;
+        exportModifier.flags = this.p.contextFlags | 8 /* NodeFlags.Reparsed */;
+        return this.p.newModifierList(locationNode.pos, locationNode.end, [exportModifier]);
+    }
+    /** The innermost identifier of a JSDoc namespace chain: `C` for `A.B.C`. */
+    getInnermostNameOfJSDocNamespace(fullName) {
+        if (fullName === undefined)
+            return undefined;
+        while (fullName instanceof ModuleDeclaration) {
+            const body = fullName.body;
+            if (body === undefined)
+                return fullName.name;
+            fullName = body;
+        }
+        return fullName;
+    }
+    /** Wraps `statement` in namespaces for a dotted JSDoc name: `A.B.C` gives `namespace A { namespace B { … } }`. */
+    wrapInJSDocNamespace(fullName, statement, nested) {
+        if (!(fullName instanceof ModuleDeclaration))
+            return statement;
+        // Inner namespaces are exported for dotted access; the binder treats the outermost one as
+        // exported in module files.
+        const wrapped = this.wrapInJSDocNamespace(fullName.body, statement, true);
+        const block = new ModuleBlock(this.p.newNodeList(fullName.pos, fullName.end, [wrapped]));
+        this.finishReparsedNode(block, fullName);
+        const modifiers = nested ? this.createExportModifier(fullName) : undefined;
+        const result = new ModuleDeclaration(modifiers, 145 /* SyntaxKind.NamespaceKeyword */, this.addDeepCloneReparse(fullName.name), block);
+        this.finishReparsedNode(result, fullName);
+        this.p.reparsedClones.push(result);
+        return result;
+    }
+}
+/** The JSDoc parameter tag's matching parameter, by name or by position. */
+function findMatchingParameter(fun, parameterTag, jsDoc) {
+    let tagIndex = -1;
+    let paramCount = -1;
+    if (jsDoc.tags !== undefined)
+        for (const tag of jsDoc.tags.nodes)
+            if (tag.kind === 333 /* SyntaxKind.JSDocParameterTag */) {
+                paramCount++;
+                if (tag === parameterTag) {
+                    tagIndex = paramCount;
+                    break;
+                }
+            }
+    const parameters = getParameters(fun);
+    if (parameters === undefined)
+        return undefined;
+    const params = parameters.nodes;
+    const tagName = parameterTag.name;
+    let parameterIndex = 0;
+    for (const node of params) {
+        const parameter = asParameterDeclaration(node);
+        if (parameter !== undefined && parameterMatches(parameter, tagName, parameterIndex === tagIndex))
+            return parameter;
+        parameterIndex++;
+    }
+    return undefined;
+}
+// Narrowing helpers. scriptc types indexed array elements as possibly undefined and can't narrow
+// those to a class with `instanceof`; these take `for…of` elements.
+function asJSDoc(node) {
+    if (node instanceof JSDoc)
+        return node;
+    return undefined;
+}
+function asParameterOrPropertyTag(node) {
+    if (node instanceof JSDocParameterOrPropertyTag)
+        return node;
+    return undefined;
+}
+function asParameterDeclaration(node) {
+    if (node instanceof ParameterDeclaration)
+        return node;
+    return undefined;
+}
+function parameterMatches(parameter, tagName, isTagIndex) {
+    const name = parameter.name;
+    if (name instanceof Identifier)
+        return (tagName instanceof Identifier &&
+            (name.text === tagName.text ||
+                (isTagIndex && tagName.text.length === 0)));
+    return isTagIndex;
+}
+/** The function documented by a JSDoc host: the host itself, or a function in its initializer or expression. */
+function getFunctionLikeHost(host) {
+    let fun = host;
+    if (host instanceof VariableStatement) {
+        const nodes = host.declarationList.declarations.nodes;
+        if (nodes.length !== 0) {
+            const first = nodes[0];
+            fun = first instanceof VariableDeclaration ? first.initializer : undefined;
+        }
+    }
+    else if (host.kind === 303 /* SyntaxKind.PropertyAssignment */ || host.kind === 173 /* SyntaxKind.PropertyDeclaration */) {
+        fun = getInitializer(host);
+    }
+    else if (host instanceof ExportAssignment) {
+        fun = host.expression;
+    }
+    else if (host instanceof ReturnStatement) {
+        fun = host.expression;
+    }
+    else if (host instanceof ExpressionStatement) {
+        fun = getRightMostAssignedExpression(host.expression);
+    }
+    while (fun instanceof SatisfiesExpression)
+        fun = fun.expression;
+    return isFunctionLike(fun) ? fun : undefined;
+}
+function getRightMostAssignedExpression(node) {
+    while (node instanceof BinaryExpression &&
+        (node.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ ||
+            isAssignmentOperator(node.operatorToken.kind)) &&
+        isLeftHandSideExpression(node.left))
+        node = node.right;
+    return node;
+}
+function getExpressionOfReturnOrParenthesized(node) {
+    if (node instanceof ReturnStatement)
+        return node.expression;
+    if (node instanceof ParenthesizedExpression)
+        return node.expression;
+    if (node instanceof ExportAssignment)
+        return node.expression;
+    return undefined;
+}
+function hasSamePropertyAccessName(node1, node2) {
+    if (node1 instanceof Identifier && node2 instanceof Identifier)
+        return node1.text === node2.text;
+    if (node1 instanceof PropertyAccessExpression && node2 instanceof PropertyAccessExpression) {
+        return (getText(node1.name) === getText(node2.name) &&
+            hasSamePropertyAccessName(node1.expression, node2.expression));
+    }
+    return false;
+}
+// Assignment declarations (tsgo's GetAssignmentDeclarationKind(node) != JSDeclarationKindNone).
+function isIdentifierNamed(node, text) {
+    return node instanceof Identifier && node.text === text;
+}
+function skipParentheses(node) {
+    while (node instanceof ParenthesizedExpression)
+        node = node.expression;
+    return node;
+}
+function isStringOrNumericLiteralLike(node) {
+    return isStringLiteralLike(node) || node instanceof NumericLiteral;
+}
+function getAccessExpression(node) {
+    if (node instanceof PropertyAccessExpression)
+        return node.expression;
+    if (node instanceof ElementAccessExpression)
+        return node.expression;
+    return undefined;
+}
+/** The name of a property access with an identifier name, or an element access with a literal argument. */
+function getElementOrPropertyAccessName(node) {
+    if (node instanceof PropertyAccessExpression)
+        return node.name instanceof Identifier
+            ? node.name
+            : undefined;
+    if (node instanceof ElementAccessExpression) {
+        const argument = skipParentheses(node.argumentExpression);
+        return isStringOrNumericLiteralLike(argument) ? argument : undefined;
+    }
+    return undefined;
+}
+function isModuleExportsAccessExpression(node) {
+    const expression = getAccessExpression(node);
+    if (expression !== undefined && isIdentifierNamed(expression, 'module')) {
+        const name = getElementOrPropertyAccessName(node);
+        return name !== undefined && getText(name) === 'exports';
+    }
+    return false;
+}
+function isEntityNameExpression(node, allowJS) {
+    if (node instanceof Identifier)
+        return true;
+    if (node instanceof PropertyAccessExpression)
+        return (node.name instanceof Identifier &&
+            isEntityNameExpression(node.expression, allowJS));
+    if (!allowJS)
+        return false;
+    if (node.kind === 109 /* SyntaxKind.ThisKeyword */)
+        return true;
+    return (node instanceof ElementAccessExpression &&
+        isStringOrNumericLiteralLike(node.argumentExpression) &&
+        isEntityNameExpression(node.expression, allowJS));
+}
+function isBindableStaticAccessExpression(node, excludeThisKeyword) {
+    if (node instanceof PropertyAccessExpression)
+        return ((!excludeThisKeyword && node.expression.kind === 109 /* SyntaxKind.ThisKeyword */) ||
+            (node.name instanceof Identifier &&
+                isBindableStaticNameExpression(node.expression, true)));
+    return isBindableStaticElementAccessExpression(node, excludeThisKeyword);
+}
+function isBindableStaticElementAccessExpression(node, excludeThisKeyword) {
+    return (node instanceof ElementAccessExpression &&
+        isStringOrNumericLiteralLike(node.argumentExpression) &&
+        ((!excludeThisKeyword && node.expression.kind === 109 /* SyntaxKind.ThisKeyword */) ||
+            isEntityNameExpression(node.expression, false) ||
+            isBindableStaticAccessExpression(node.expression, true)));
+}
+function isBindableStaticNameExpression(node, excludeThisKeyword) {
+    return isEntityNameExpression(node, false) || isBindableStaticAccessExpression(node, excludeThisKeyword);
+}
+function isAssignmentDeclaration(bin) {
+    const left = bin.left;
+    if (bin.operatorToken.kind !== 63 /* SyntaxKind.EqualsToken */)
+        return false;
+    const leftExpression = getAccessExpression(left);
+    if (leftExpression === undefined)
+        return false;
+    const inJS = isInJSFile(left);
+    if (inJS) {
+        if (isModuleExportsAccessExpression(left) && !isIdentifierNamed(bin.right, 'exports'))
+            return true;
+        if ((isModuleExportsAccessExpression(leftExpression) || isIdentifierNamed(leftExpression, 'exports')) &&
+            getElementOrPropertyAccessName(left) !== undefined)
+            return true;
+        if (leftExpression.kind === 109 /* SyntaxKind.ThisKeyword */)
+            return true;
+    }
+    if (left instanceof PropertyAccessExpression)
+        return (isEntityNameExpression(left.expression, inJS) &&
+            left.name instanceof Identifier);
+    return (left instanceof ElementAccessExpression &&
+        isEntityNameExpression(left.expression, inJS));
+}
+// Fields of function-like and other hosts. (One `instanceof` per statement: scriptc can't access
+// fields through a union of classes.)
+function getFullSignature(node) {
+    if (node instanceof FunctionDeclaration)
+        return node.fullSignature;
+    if (node instanceof MethodDeclaration)
+        return node.fullSignature;
+    if (node instanceof ConstructorDeclaration)
+        return node.fullSignature;
+    if (node instanceof GetAccessorDeclaration)
+        return node.fullSignature;
+    if (node instanceof SetAccessorDeclaration)
+        return node.fullSignature;
+    if (node instanceof FunctionExpression)
+        return node.fullSignature;
+    if (node instanceof ArrowFunction)
+        return node.fullSignature;
+    return undefined;
+}
+/** tsgo stores a full signature on every function-like node, but only these visit it. */
+function setFullSignature(node, value) {
+    if (node instanceof FunctionDeclaration) {
+        node.fullSignature = value;
+        return true;
+    }
+    if (node instanceof MethodDeclaration) {
+        node.fullSignature = value;
+        return true;
+    }
+    if (node instanceof ConstructorDeclaration) {
+        node.fullSignature = value;
+        return true;
+    }
+    if (node instanceof GetAccessorDeclaration) {
+        node.fullSignature = value;
+        return true;
+    }
+    if (node instanceof SetAccessorDeclaration) {
+        node.fullSignature = value;
+        return true;
+    }
+    if (node instanceof FunctionExpression) {
+        node.fullSignature = value;
+        return true;
+    }
+    if (node instanceof ArrowFunction) {
+        node.fullSignature = value;
+        return true;
+    }
+    return false;
+}
+function setTypeParameters(node, value) {
+    if (node instanceof FunctionDeclaration) {
+        node.typeParameters = value;
+        return true;
+    }
+    if (node instanceof MethodDeclaration) {
+        node.typeParameters = value;
+        return true;
+    }
+    if (node instanceof ConstructorDeclaration) {
+        node.typeParameters = value;
+        return true;
+    }
+    if (node instanceof GetAccessorDeclaration) {
+        node.typeParameters = value;
+        return true;
+    }
+    if (node instanceof SetAccessorDeclaration) {
+        node.typeParameters = value;
+        return true;
+    }
+    if (node instanceof FunctionExpression) {
+        node.typeParameters = value;
+        return true;
+    }
+    if (node instanceof ArrowFunction) {
+        node.typeParameters = value;
+        return true;
+    }
+    if (node instanceof MethodSignatureDeclaration) {
+        node.typeParameters = value;
+        return true;
+    }
+    if (node instanceof CallSignatureDeclaration) {
+        node.typeParameters = value;
+        return true;
+    }
+    if (node instanceof ConstructSignatureDeclaration) {
+        node.typeParameters = value;
+        return true;
+    }
+    if (node instanceof FunctionTypeNode) {
+        node.typeParameters = value;
+        return true;
+    }
+    if (node instanceof ConstructorTypeNode) {
+        node.typeParameters = value;
+        return true;
+    }
+    if (node instanceof JSDocSignature) {
+        node.typeParameters = value;
+        return true;
+    }
+    return false;
+}
+function setParameters(node, value) {
+    if (node instanceof FunctionDeclaration) {
+        node.parameters = value;
+        return true;
+    }
+    if (node instanceof MethodDeclaration) {
+        node.parameters = value;
+        return true;
+    }
+    if (node instanceof ConstructorDeclaration) {
+        node.parameters = value;
+        return true;
+    }
+    if (node instanceof GetAccessorDeclaration) {
+        node.parameters = value;
+        return true;
+    }
+    if (node instanceof SetAccessorDeclaration) {
+        node.parameters = value;
+        return true;
+    }
+    if (node instanceof FunctionExpression) {
+        node.parameters = value;
+        return true;
+    }
+    if (node instanceof ArrowFunction) {
+        node.parameters = value;
+        return true;
+    }
+    if (node instanceof MethodSignatureDeclaration) {
+        node.parameters = value;
+        return true;
+    }
+    if (node instanceof CallSignatureDeclaration) {
+        node.parameters = value;
+        return true;
+    }
+    if (node instanceof ConstructSignatureDeclaration) {
+        node.parameters = value;
+        return true;
+    }
+    if (node instanceof IndexSignatureDeclaration) {
+        node.parameters = value;
+        return true;
+    }
+    if (node instanceof FunctionTypeNode) {
+        node.parameters = value;
+        return true;
+    }
+    if (node instanceof ConstructorTypeNode) {
+        node.parameters = value;
+        return true;
+    }
+    if (node instanceof JSDocSignature) {
+        node.parameters = value;
+        return true;
+    }
+    return false;
+}
+function setType(node, value) {
+    if (node instanceof FunctionDeclaration) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof MethodDeclaration) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof ConstructorDeclaration) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof GetAccessorDeclaration) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof SetAccessorDeclaration) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof FunctionExpression) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof ArrowFunction) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof MethodSignatureDeclaration) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof CallSignatureDeclaration) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof ConstructSignatureDeclaration) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof IndexSignatureDeclaration) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof FunctionTypeNode) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof ConstructorTypeNode) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof JSDocSignature) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof VariableDeclaration) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof ExportAssignment) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof PropertyDeclaration) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof PropertyAssignment) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof ShorthandPropertyAssignment) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof ParameterDeclaration) {
+        node.type = value;
+        return true;
+    }
+    if (node instanceof BinaryExpression) {
+        node.type = value;
+        return true;
+    }
+    return false;
+}
+function setExpression(node, value) {
+    if (node instanceof ReturnStatement) {
+        node.expression = value;
+        return true;
+    }
+    if (node instanceof ParenthesizedExpression) {
+        node.expression = value;
+        return true;
+    }
+    if (node instanceof ExportAssignment) {
+        node.expression = value;
+        return true;
+    }
+    return false;
+}
+function setModifiers(node, value) {
+    if (node instanceof MethodDeclaration) {
+        node.modifiers = value;
+        return true;
+    }
+    if (node instanceof GetAccessorDeclaration) {
+        node.modifiers = value;
+        return true;
+    }
+    if (node instanceof SetAccessorDeclaration) {
+        node.modifiers = value;
+        return true;
+    }
+    if (node instanceof PropertyDeclaration) {
+        node.modifiers = value;
+        return true;
+    }
+    if (node instanceof ConstructorDeclaration) {
+        node.modifiers = value;
+        return true;
+    }
+    if (node instanceof BinaryExpression) {
+        node.modifiers = value;
+        return true;
+    }
+    return false;
+}
+function getInitializer(node) {
+    if (node instanceof VariableDeclaration)
+        return node.initializer;
+    if (node instanceof PropertyDeclaration)
+        return node.initializer;
+    if (node instanceof PropertyAssignment)
+        return node.initializer;
+    return undefined;
+}
+function setInitializer(node, value) {
+    if (node instanceof VariableDeclaration) {
+        node.initializer = value;
+        return true;
+    }
+    if (node instanceof PropertyDeclaration) {
+        node.initializer = value;
+        return true;
+    }
+    if (node instanceof PropertyAssignment) {
+        node.initializer = value;
+        return true;
+    }
+    return false;
+}
+function getHeritageClauses(node) {
+    if (node instanceof ClassDeclaration)
+        return node.heritageClauses;
+    if (node instanceof ClassExpression)
+        return node.heritageClauses;
+    return undefined;
+}
+function setHeritageClauses(node, value) {
+    if (node instanceof ClassDeclaration) {
+        node.heritageClauses = value;
+        return true;
+    }
+    if (node instanceof ClassExpression) {
+        node.heritageClauses = value;
+        return true;
+    }
+    return false;
+}
+function getClassTypeParameters(node) {
+    if (node instanceof ClassDeclaration)
+        return node.typeParameters;
+    if (node instanceof ClassExpression)
+        return node.typeParameters;
+    return undefined;
+}
+function setClassTypeParameters(node, value) {
+    if (node instanceof ClassDeclaration) {
+        node.typeParameters = value;
+        return true;
+    }
+    if (node instanceof ClassExpression) {
+        node.typeParameters = value;
+        return true;
+    }
+    return false;
+}
+/** Whether `s` is a valid identifier: an identifier start followed by identifier parts. */
+function isValidIdentifier(s) {
+    if (s.length === 0)
+        return false;
+    for (let i = 0; i < s.length;) {
+        const ch = s.codePointAt(i);
+        if (i === 0 ? !isIdentifierStart(ch) : !isIdentifierPart(ch))
+            return false;
+        i += ch > 0xffff ? 2 : 1;
+    }
+    return true;
+}
+/** `s` with invalid identifier characters replaced by `_`, or `_<index>` if empty. */
+function sanitizeIdentifier(s, index) {
+    let result = '';
+    for (let i = 0; i < s.length;) {
+        const ch = s.codePointAt(i);
+        const valid = i === 0 ? isIdentifierStart(ch) : isIdentifierPart(ch);
+        result += valid ? String.fromCodePoint(ch) : '_';
+        i += ch > 0xffff ? 2 : 1;
+    }
+    return result.length === 0 ? '_' + index : result;
+}