tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/transformers/tagged-template.js

@@ -0,0 +1,148 @@
+// Lowers tagged templates with invalid escapes, allowed in tagged templates since ES2018, to
+// calls with a `__makeTemplateObject` template object.
+import { ArrayLiteralExpression, CallExpression, NoSubstitutionTemplateLiteral, SourceFile, TaggedTemplateExpression, TemplateExpression, TemplateMiddle, TemplateTail, } from '../ast.js';
+import { getSourceTextOfNode } from '../printer/utilities.js';
+import { Transformer } from './transformer.js';
+import { isExternalModule } from './utilities.js';
+export class TaggedTemplateTransformer extends Transformer {
+    facts;
+    file;
+    /** `templateObject` variables, declared at the end of a module. */
+    declarations;
+    constructor(context, facts) {
+        super(context);
+        this.facts = facts;
+        this.file = undefined;
+        this.declarations = [];
+    }
+    visit(node) {
+        if (!this.facts.has(node, 2097152 /* SubtreeFacts.ContainsInvalidTemplateEscape */))
+            return node;
+        if (node instanceof SourceFile)
+            return this.visitSourceFile(node);
+        if (node instanceof TaggedTemplateExpression)
+            return this.visitTaggedTemplate(node);
+        return this.visitEachChild(node);
+    }
+    visitSourceFile(node) {
+        const factory = this.factory;
+        this.file = node;
+        this.declarations = [];
+        let visited = this.visitEachChild(node);
+        if (this.declarations.length > 0) {
+            const statements = visited.statements.nodes.slice();
+            statements.push(factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList(this.declarations), 0 /* NodeFlags.None */)));
+            const list = factory.createNodeList(statements);
+            list.pos = node.statements.pos;
+            list.end = node.statements.end;
+            visited = factory.updateSourceFile(visited, list, visited.endOfFileToken);
+        }
+        const helpers = this.context.readEmitHelpers();
+        for (let i = 0; i < helpers.length; i++)
+            this.context.addEmitHelper(visited, helpers[i]);
+        return visited;
+    }
+    visitTaggedTemplate(node) {
+        const factory = this.factory;
+        const tag = this.visitNode(node.tag);
+        const template = node.template;
+        if (!hasInvalidEscape(template))
+            return this.visitEachChild(node);
+        const args = [];
+        const cooked = [];
+        const raw = [];
+        if (template instanceof NoSubstitutionTemplateLiteral) {
+            cooked.push(this.cookedString(template.text, template.templateFlags));
+            raw.push(this.rawString(template, ''));
+        }
+        else if (template instanceof TemplateExpression) {
+            const head = template.head;
+            cooked.push(this.cookedString(head.text, head.templateFlags));
+            raw.push(this.rawString(head, head.rawText));
+            const spans = template.templateSpans.nodes;
+            for (let i = 0; i < spans.length; i++) {
+                const span = spans[i];
+                const literal = span.literal;
+                if (literal instanceof TemplateMiddle) {
+                    cooked.push(this.cookedString(literal.text, literal.templateFlags));
+                    raw.push(this.rawString(literal, literal.rawText));
+                }
+                else if (literal instanceof TemplateTail) {
+                    cooked.push(this.cookedString(literal.text, literal.templateFlags));
+                    raw.push(this.rawString(literal, literal.rawText));
+                }
+                args.push(this.visitNode(span.expression));
+            }
+        }
+        const helperCall = factory.createTemplateObjectHelper(factory.created(new ArrayLiteralExpression(factory.createNodeList(cooked), false)), factory.created(new ArrayLiteralExpression(factory.createNodeList(raw), false)));
+        // Modules cache the template object; scripts don't, as the variable could clash with other scripts.
+        let templateObject = helperCall;
+        if (this.file !== undefined && isExternalModule(this.file)) {
+            const name = factory.createUniqueName('templateObject', 0);
+            this.declarations.push(factory.createVariableDeclaration(name, undefined, undefined, undefined));
+            templateObject = factory.createLogicalOr(name, factory.createAssignment(name, helperCall));
+        }
+        args.unshift(templateObject);
+        const call = factory.created(new CallExpression(tag, undefined, undefined, factory.createNodeList(args), 0));
+        call.pos = node.pos;
+        call.end = node.end;
+        return call;
+    }
+    cookedString(text, flags) {
+        if ((flags & 26656 /* TokenFlags.IsInvalid */) !== 0)
+            return this.factory.createVoidZero();
+        return this.factory.createStringLiteral(text, 0 /* TokenFlags.None */);
+    }
+    /** The raw text of a template literal part, with line terminators normalized to `\n`. */
+    rawString(node, rawText) {
+        let text = rawText;
+        if (text === '' && this.file !== undefined) {
+            // The source text includes the delimiters: "`" or "}" before and "`" or "${" after.
+            text = getSourceTextOfNode(this.file.text, node);
+            const last = node.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */ || node.kind === 17 /* SyntaxKind.TemplateTail */;
+            text = text.slice(1, text.length - (last ? 1 : 2));
+        }
+        const literal = this.factory.createStringLiteral(normalizeLineTerminators(text), 0 /* TokenFlags.None */);
+        literal.pos = node.pos;
+        literal.end = node.end;
+        return literal;
+    }
+}
+function hasInvalidEscape(template) {
+    if (template instanceof NoSubstitutionTemplateLiteral)
+        return invalid(template.templateFlags);
+    if (!(template instanceof TemplateExpression))
+        return false;
+    const head = template.head;
+    if (invalid(head.templateFlags))
+        return true;
+    const spans = template.templateSpans.nodes;
+    for (let i = 0; i < spans.length; i++) {
+        const literal = spans[i].literal;
+        if (literal instanceof TemplateMiddle && invalid(literal.templateFlags))
+            return true;
+        if (literal instanceof TemplateTail && invalid(literal.templateFlags))
+            return true;
+    }
+    return false;
+}
+function invalid(flags) {
+    return (flags & 2048 /* TokenFlags.ContainsInvalidEscape */) !== 0;
+}
+/** `\r\n` and `\r` as `\n`, as template values and raw values are (ES2015 11.8.6.1). */
+function normalizeLineTerminators(text) {
+    if (text.indexOf('\r') < 0)
+        return text;
+    let result = '';
+    for (let i = 0; i < text.length; i++) {
+        const ch = text.charAt(i);
+        if (ch !== '\r')
+            result += ch;
+        else {
+            result += '\n';
+            if (i + 1 < text.length && text.charAt(i + 1) === '\n')
+                i++;
+        }
+    }
+    return result;
+}

package/dist/api/compiler/transformers/transformer.d.ts

@@ -0,0 +1,17 @@
+import { ModifierList, type Node, SourceFile } from '../ast.js';
+import type { ModifierFlags } from '../ast.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import { NotEmittedStatement } from '../ast.js';
+import { VisitorBase } from './visitor-base.js';
+export declare abstract class Transformer extends VisitorBase {
+    /** What this transform couldn't handle in the last file, or `''`. */
+    unsupported: string;
+    constructor(context: EmitContext);
+    /** Records syntax this transform doesn't implement yet; emit of the file is skipped. */
+    unsupportedNode(node: Node, what: string): Node;
+    transformSourceFile(file: SourceFile): SourceFile;
+    /** A statement that prints nothing but keeps the comments of `node`. */
+    notEmitted(node: Node): NotEmittedStatement;
+    /** The modifiers of `modifiers` whose flags are in `allowed`. */
+    extractModifiers(modifiers: ModifierList | undefined, allowed: ModifierFlags): ModifierList | undefined;
+}

package/dist/api/compiler/transformers/transformer.js

@@ -0,0 +1,54 @@
+// The base of every transform: a visitor over one source file at a time.
+import { SourceFile } from '../ast.js';
+import { modifierToFlag } from '../ast-utilities.js';
+import { NotEmittedStatement } from '../ast.js';
+import { VisitorBase } from './visitor-base.js';
+export class Transformer extends VisitorBase {
+    /** What this transform couldn't handle in the last file, or `''`. */
+    unsupported;
+    constructor(context) {
+        super(context);
+        this.unsupported = '';
+    }
+    /** Records syntax this transform doesn't implement yet; emit of the file is skipped. */
+    unsupportedNode(node, what) {
+        if (this.unsupported === '')
+            this.unsupported = what + ' are not supported yet';
+        return node;
+    }
+    transformSourceFile(file) {
+        const visited = this.visitNode(file);
+        if (visited instanceof SourceFile)
+            return visited;
+        throw new Error('A transform must return a source file');
+    }
+    /** A statement that prints nothing but keeps the comments of `node`. */
+    notEmitted(node) {
+        const statement = this.factory.created(new NotEmittedStatement());
+        statement.pos = node.pos;
+        statement.end = node.end;
+        this.context.setOriginal(statement, node);
+        this.context.assignCommentRange(statement, node);
+        return statement;
+    }
+    /** The modifiers of `modifiers` whose flags are in `allowed`. */
+    extractModifiers(modifiers, allowed) {
+        if (modifiers === undefined)
+            return undefined;
+        const nodes = modifiers.nodes;
+        let kept = undefined;
+        for (let i = 0; i < nodes.length; i++) {
+            const keep = (modifierToFlag(nodes[i].kind) & allowed) !== 0;
+            if (keep && kept !== undefined)
+                kept.push(nodes[i]);
+            else if (!keep && kept === undefined)
+                kept = nodes.slice(0, i);
+        }
+        if (kept === undefined)
+            return modifiers;
+        const list = this.factory.createModifierList(kept);
+        list.pos = modifiers.pos;
+        list.end = modifiers.end;
+        return list;
+    }
+}

package/dist/api/compiler/transformers/type-eraser.d.ts

@@ -0,0 +1,21 @@
+import { type Node } from '../ast.js';
+import type { CompilerOptions } from '../options.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import { type TypeScriptFacts } from './subtree-facts.js';
+import { Transformer } from './transformer.js';
+export declare class TypeEraser extends Transformer {
+    readonly options: CompilerOptions;
+    readonly facts: TypeScriptFacts;
+    private parentNode;
+    private currentNode;
+    constructor(context: EmitContext, options: CompilerOptions, facts: TypeScriptFacts);
+    visit(node: Node): Node | undefined;
+    private visitWorker;
+    private required;
+    private optionalIdentifier;
+    private jsxAttributes;
+    private importAttributes;
+    private accessorBody;
+    private partiallyEmitted;
+    private visitParameter;
+}

package/dist/api/compiler/transformers/type-eraser.js

@@ -0,0 +1,346 @@
+// Removes TypeScript-only syntax: type annotations and declarations, `declare`d statements,
+// type-only imports and exports, and modifiers such as `public` and `readonly`.
+import { CallExpression, ClassDeclaration, ClassExpression, ConstructorDeclaration, ExportDeclaration, ExportSpecifier, ExpressionWithTypeArguments, FunctionDeclaration, FunctionExpression, GetAccessorDeclaration, HeritageClause, Identifier, ImportClause, ImportDeclaration, ImportAttributes, ImportEqualsDeclaration, ImportSpecifier, JsxAttributes, JsxOpeningElement, JsxSelfClosingElement, MethodDeclaration, ModuleDeclaration, NamedExports, NamedImports, NewExpression, ParameterDeclaration, ParenthesizedExpression, PartiallyEmittedExpression, PropertyDeclaration, SetAccessorDeclaration, TaggedTemplateExpression, VariableDeclaration, ArrowFunction, getExpression, } from '../ast.js';
+import { nodeIsMissing } from '../ast-utilities.js';
+import { shouldPreserveConstEnums } from '../options.js';
+import { isStatement } from '../printer/utilities.js';
+import { Transformer } from './transformer.js';
+import { getInnermostModuleDeclaration, hasDecorators, hasSyntacticModifier, isInstantiatedModule, isJSDocTypeAssertion, isParameterPropertyDeclaration, isThisParameter, } from './utilities.js';
+export class TypeEraser extends Transformer {
+    options;
+    facts;
+    parentNode;
+    currentNode;
+    constructor(context, options, facts) {
+        super(context);
+        this.options = options;
+        this.facts = facts;
+        this.parentNode = undefined;
+        this.currentNode = undefined;
+    }
+    visit(node) {
+        if (!this.facts.containsTypeScript(node))
+            return node;
+        if (isStatement(node) && hasSyntacticModifier(node, 128 /* ModifierFlags.Ambient */))
+            return this.notEmitted(node);
+        const grandparent = this.parentNode;
+        this.parentNode = this.currentNode;
+        this.currentNode = node;
+        const result = this.visitWorker(node);
+        this.currentNode = this.parentNode;
+        this.parentNode = grandparent;
+        return result;
+    }
+    visitWorker(node) {
+        const factory = this.factory;
+        switch (node.kind) {
+            case 124 /* SyntaxKind.PublicKeyword */:
+            case 122 /* SyntaxKind.PrivateKeyword */:
+            case 123 /* SyntaxKind.ProtectedKeyword */:
+            case 127 /* SyntaxKind.AbstractKeyword */:
+            case 164 /* SyntaxKind.OverrideKeyword */:
+            case 86 /* SyntaxKind.ConstKeyword */:
+            case 137 /* SyntaxKind.DeclareKeyword */:
+            case 148 /* SyntaxKind.ReadonlyKeyword */:
+            case 189 /* SyntaxKind.ArrayType */:
+            case 190 /* SyntaxKind.TupleType */:
+            case 191 /* SyntaxKind.OptionalType */:
+            case 192 /* SyntaxKind.RestType */:
+            case 188 /* SyntaxKind.TypeLiteral */:
+            case 183 /* SyntaxKind.TypePredicate */:
+            case 169 /* SyntaxKind.TypeParameter */:
+            case 132 /* SyntaxKind.AnyKeyword */:
+            case 159 /* SyntaxKind.UnknownKeyword */:
+            case 135 /* SyntaxKind.BooleanKeyword */:
+            case 154 /* SyntaxKind.StringKeyword */:
+            case 150 /* SyntaxKind.NumberKeyword */:
+            case 146 /* SyntaxKind.NeverKeyword */:
+            case 115 /* SyntaxKind.VoidKeyword */:
+            case 155 /* SyntaxKind.SymbolKeyword */:
+            case 186 /* SyntaxKind.ConstructorType */:
+            case 185 /* SyntaxKind.FunctionType */:
+            case 187 /* SyntaxKind.TypeQuery */:
+            case 184 /* SyntaxKind.TypeReference */:
+            case 193 /* SyntaxKind.UnionType */:
+            case 194 /* SyntaxKind.IntersectionType */:
+            case 195 /* SyntaxKind.ConditionalType */:
+            case 197 /* SyntaxKind.ParenthesizedType */:
+            case 198 /* SyntaxKind.ThisType */:
+            case 199 /* SyntaxKind.TypeOperator */:
+            case 200 /* SyntaxKind.IndexedAccessType */:
+            case 201 /* SyntaxKind.MappedType */:
+            case 202 /* SyntaxKind.LiteralType */:
+            case 182 /* SyntaxKind.IndexSignature */:
+            case 346 /* SyntaxKind.JSImportDeclaration */:
+            case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+                return undefined;
+            case 102 /* SyntaxKind.InKeyword */:
+            case 147 /* SyntaxKind.OutKeyword */:
+                if (this.parentNode === undefined || this.parentNode.kind !== 227 /* SyntaxKind.BinaryExpression */)
+                    return undefined;
+                return this.visitEachChild(node);
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+                return this.notEmitted(node);
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+                if (node instanceof ModuleDeclaration) {
+                    if (!(node.name instanceof Identifier) ||
+                        !isInstantiatedModule(node, shouldPreserveConstEnums(this.options)) ||
+                        getInnermostModuleDeclaration(node).body === undefined)
+                        return this.notEmitted(node);
+                    return this.visitEachChild(node);
+                }
+                break;
+            case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+                if (node instanceof ExpressionWithTypeArguments)
+                    return factory.updateExpressionWithTypeArguments(node, this.required(node.expression), undefined);
+                break;
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+                if (node instanceof PropertyDeclaration) {
+                    const ambientOrAbstract = hasSyntacticModifier(node, 128 /* ModifierFlags.Ambient */ | 64 /* ModifierFlags.Abstract */);
+                    if (ambientOrAbstract && !(this.options.experimentalDecorators === true && hasDecorators(node)))
+                        return undefined;
+                    return factory.updatePropertyDeclaration(node, this.visitModifiers(node.modifiers), this.required(node.name), undefined, undefined, this.visitNode(node.initializer));
+                }
+                break;
+            case 177 /* SyntaxKind.Constructor */:
+                if (node instanceof ConstructorDeclaration) {
+                    if (nodeIsMissing(node.body))
+                        return undefined;
+                    return factory.updateConstructorDeclaration(node, undefined, undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body));
+                }
+                break;
+            case 175 /* SyntaxKind.MethodDeclaration */:
+                if (node instanceof MethodDeclaration) {
+                    if (nodeIsMissing(node.body))
+                        return undefined;
+                    return factory.updateMethodDeclaration(node, this.visitModifiers(node.modifiers), node.asteriskToken, this.required(node.name), undefined, undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body));
+                }
+                break;
+            case 178 /* SyntaxKind.GetAccessor */:
+                if (node instanceof GetAccessorDeclaration) {
+                    if (nodeIsMissing(node.body) && hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */))
+                        return undefined;
+                    return factory.updateGetAccessorDeclaration(node, this.visitModifiers(node.modifiers), this.required(node.name), undefined, this.visitNodes(node.parameters), undefined, undefined, this.accessorBody(node.body));
+                }
+                break;
+            case 179 /* SyntaxKind.SetAccessor */:
+                if (node instanceof SetAccessorDeclaration) {
+                    if (nodeIsMissing(node.body) && hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */))
+                        return undefined;
+                    return factory.updateSetAccessorDeclaration(node, this.visitModifiers(node.modifiers), this.required(node.name), undefined, this.visitNodes(node.parameters), undefined, undefined, this.accessorBody(node.body));
+                }
+                break;
+            case 261 /* SyntaxKind.VariableDeclaration */:
+                if (node instanceof VariableDeclaration) {
+                    const updated = factory.updateVariableDeclaration(node, this.required(node.name), undefined, undefined, this.visitNode(node.initializer));
+                    if (node.type !== undefined)
+                        this.context.setTypeNode(updated.name, node.type);
+                    return updated;
+                }
+                break;
+            case 299 /* SyntaxKind.HeritageClause */:
+                if (node instanceof HeritageClause) {
+                    if (node.token === 118 /* SyntaxKind.ImplementsKeyword */)
+                        return undefined;
+                    return factory.updateHeritageClause(node, node.token, this.visitNodes(node.types));
+                }
+                break;
+            case 264 /* SyntaxKind.ClassDeclaration */:
+                if (node instanceof ClassDeclaration)
+                    return factory.updateClassDeclaration(node, this.visitModifiers(node.modifiers), this.optionalIdentifier(node.name), undefined, this.visitNodes(node.heritageClauses), this.visitNodes(node.members));
+                break;
+            case 232 /* SyntaxKind.ClassExpression */:
+                if (node instanceof ClassExpression)
+                    return factory.updateClassExpression(node, this.visitModifiers(node.modifiers), this.optionalIdentifier(node.name), undefined, this.visitNodes(node.heritageClauses), this.visitNodes(node.members));
+                break;
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+                if (node instanceof FunctionDeclaration) {
+                    if (nodeIsMissing(node.body))
+                        return this.notEmitted(node);
+                    return factory.updateFunctionDeclaration(node, this.visitModifiers(node.modifiers), node.asteriskToken, this.optionalIdentifier(node.name), undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body));
+                }
+                break;
+            case 219 /* SyntaxKind.FunctionExpression */:
+                if (node instanceof FunctionExpression)
+                    return factory.updateFunctionExpression(node, this.visitModifiers(node.modifiers), node.asteriskToken, this.optionalIdentifier(node.name), undefined, this.visitNodes(node.parameters), undefined, undefined, this.required(node.body));
+                break;
+            case 220 /* SyntaxKind.ArrowFunction */:
+                if (node instanceof ArrowFunction)
+                    return factory.updateArrowFunction(node, this.visitModifiers(node.modifiers), undefined, this.visitNodes(node.parameters), undefined, undefined, node.equalsGreaterThanToken, this.required(node.body));
+                break;
+            case 170 /* SyntaxKind.Parameter */:
+                if (node instanceof ParameterDeclaration)
+                    return this.visitParameter(node);
+                break;
+            case 214 /* SyntaxKind.CallExpression */:
+                if (node instanceof CallExpression)
+                    return factory.updateCallExpression(node, this.required(node.expression), node.questionDotToken, undefined, this.visitNodes(node.arguments), node.flags);
+                break;
+            case 215 /* SyntaxKind.NewExpression */:
+                if (node instanceof NewExpression)
+                    return factory.updateNewExpression(node, this.required(node.expression), undefined, this.visitNodes(node.arguments));
+                break;
+            case 216 /* SyntaxKind.TaggedTemplateExpression */:
+                if (node instanceof TaggedTemplateExpression)
+                    return factory.updateTaggedTemplateExpression(node, this.required(node.tag), node.questionDotToken, undefined, this.required(node.template), node.flags);
+                break;
+            case 236 /* SyntaxKind.NonNullExpression */:
+            case 217 /* SyntaxKind.TypeAssertionExpression */:
+            case 235 /* SyntaxKind.AsExpression */:
+            case 239 /* SyntaxKind.SatisfiesExpression */:
+                return this.partiallyEmitted(node, getExpression(node));
+            case 218 /* SyntaxKind.ParenthesizedExpression */:
+                if (node instanceof ParenthesizedExpression && !isJSDocTypeAssertion(node)) {
+                    const inner = skipParenthesesAndPartiallyEmitted(node.expression);
+                    if (inner.kind === 217 /* SyntaxKind.TypeAssertionExpression */ ||
+                        inner.kind === 235 /* SyntaxKind.AsExpression */ ||
+                        inner.kind === 239 /* SyntaxKind.SatisfiesExpression */)
+                        return this.partiallyEmitted(node, node.expression);
+                }
+                return this.visitEachChild(node);
+            case 286 /* SyntaxKind.JsxSelfClosingElement */:
+                if (node instanceof JsxSelfClosingElement)
+                    return factory.updateJsxSelfClosingElement(node, this.required(node.tagName), undefined, this.jsxAttributes(node.attributes));
+                break;
+            case 287 /* SyntaxKind.JsxOpeningElement */:
+                if (node instanceof JsxOpeningElement)
+                    return factory.updateJsxOpeningElement(node, this.required(node.tagName), undefined, this.jsxAttributes(node.attributes));
+                break;
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+                if (node instanceof ImportEqualsDeclaration && node.isTypeOnly)
+                    return undefined;
+                return this.visitEachChild(node);
+            case 273 /* SyntaxKind.ImportDeclaration */:
+                if (node instanceof ImportDeclaration) {
+                    if (node.importClause === undefined)
+                        return node;
+                    const clause = this.visitNode(node.importClause);
+                    if (!(clause instanceof ImportClause))
+                        return undefined;
+                    return factory.updateImportDeclaration(node, node.modifiers, clause, node.moduleSpecifier, node.attributes);
+                }
+                break;
+            case 274 /* SyntaxKind.ImportClause */:
+                if (node instanceof ImportClause) {
+                    if (node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */)
+                        return undefined;
+                    const bindings = this.visitNode(node.namedBindings);
+                    if (node.name === undefined && bindings === undefined)
+                        return undefined;
+                    return factory.updateImportClause(node, node.phaseModifier, node.name, bindings);
+                }
+                break;
+            case 276 /* SyntaxKind.NamedImports */:
+                if (node instanceof NamedImports) {
+                    if (node.elements.nodes.length === 0)
+                        return node;
+                    const elements = this.visitNodes(node.elements);
+                    if (this.options.verbatimModuleSyntax !== true && elements.nodes.length === 0)
+                        return undefined;
+                    return factory.updateNamedImports(node, elements);
+                }
+                break;
+            case 277 /* SyntaxKind.ImportSpecifier */:
+                return node instanceof ImportSpecifier && node.isTypeOnly ? undefined : node;
+            case 279 /* SyntaxKind.ExportDeclaration */:
+                if (node instanceof ExportDeclaration) {
+                    if (node.isTypeOnly)
+                        return undefined;
+                    let clause = undefined;
+                    if (node.exportClause !== undefined) {
+                        clause = this.visitNode(node.exportClause);
+                        if (clause === undefined)
+                            return undefined;
+                    }
+                    return factory.updateExportDeclaration(node, undefined, false, clause, this.visitNode(node.moduleSpecifier), node.attributes === undefined ? undefined : this.importAttributes(node.attributes));
+                }
+                break;
+            case 280 /* SyntaxKind.NamedExports */:
+                if (node instanceof NamedExports) {
+                    if (node.elements.nodes.length === 0)
+                        return node;
+                    const elements = this.visitNodes(node.elements);
+                    if (this.options.verbatimModuleSyntax !== true && elements.nodes.length === 0)
+                        return undefined;
+                    return factory.updateNamedExports(node, elements);
+                }
+                break;
+            case 282 /* SyntaxKind.ExportSpecifier */:
+                return node instanceof ExportSpecifier && node.isTypeOnly ? undefined : node;
+            case 267 /* SyntaxKind.EnumDeclaration */:
+                if (hasSyntacticModifier(node, 4096 /* ModifierFlags.Const */))
+                    return node;
+                return this.visitEachChild(node);
+        }
+        return this.visitEachChild(node);
+    }
+    required(node) {
+        const visited = this.visitNode(node);
+        if (visited === undefined)
+            throw new Error('A required child was removed');
+        return visited;
+    }
+    optionalIdentifier(node) {
+        const visited = this.visitNode(node);
+        if (visited === undefined)
+            return undefined;
+        if (visited instanceof Identifier)
+            return visited;
+        throw new Error('Expected an identifier');
+    }
+    jsxAttributes(node) {
+        const visited = this.visitNode(node);
+        if (visited instanceof JsxAttributes)
+            return visited;
+        throw new Error('Expected JSX attributes');
+    }
+    importAttributes(node) {
+        const visited = this.visitNode(node);
+        if (visited === undefined)
+            return undefined;
+        if (visited instanceof ImportAttributes)
+            return visited;
+        throw new Error('Expected import attributes');
+    }
+    accessorBody(body) {
+        const visited = this.visitNode(body);
+        return visited !== undefined ? visited : this.factory.createBlock([], false);
+    }
+    partiallyEmitted(node, expression) {
+        const partial = this.factory.created(new PartiallyEmittedExpression(this.required(expression)));
+        this.context.setOriginal(partial, node);
+        partial.pos = node.pos;
+        partial.end = node.end;
+        return partial;
+    }
+    visitParameter(node) {
+        if (isThisParameter(node))
+            return undefined;
+        let modifiers = undefined;
+        if (isParameterPropertyDeclaration(node, this.parentNode))
+            modifiers = this.extractModifiers(node.modifiers, 31 /* ModifierFlags.ParameterPropertyModifier */);
+        if (hasDecorators(node) && node.modifiers !== undefined) {
+            const decorators = [];
+            const nodes = node.modifiers.nodes;
+            for (let i = 0; i < nodes.length; i++)
+                if (nodes[i].kind === 171 /* SyntaxKind.Decorator */)
+                    decorators.push(nodes[i]);
+            const visited = this.visitArray(decorators);
+            modifiers = this.factory.createModifierList(modifiers === undefined ? visited : modifiers.nodes.concat(visited));
+        }
+        return this.factory.updateParameterDeclaration(node, modifiers, node.dotDotDotToken, this.required(node.name), undefined, undefined, this.visitNode(node.initializer));
+    }
+}
+/** Skips parentheses and partially emitted expressions, keeping assertions. */
+function skipParenthesesAndPartiallyEmitted(node) {
+    for (;;) {
+        if (node instanceof ParenthesizedExpression)
+            node = node.expression;
+        else if (node instanceof PartiallyEmittedExpression)
+            node = node.expression;
+        else
+            return node;
+    }
+}

package/dist/api/compiler/transformers/type-serialization.d.ts

@@ -0,0 +1,20 @@
+import { type Node } from '../ast.js';
+import { type ReferenceResolver } from './reference-resolver.js';
+/** What a type reference in decorator metadata serializes to. */
+export declare const enum TypeReferenceSerializationKind {
+    /** Unresolved: emitted with a guard in case it's undefined at runtime. */
+    Unknown = 0,
+    /** A class, or a value with construct signatures: emitted as its name. */
+    TypeWithConstructSignatureAndValue = 1,
+    VoidNullableOrNeverType = 2,
+    NumberLikeType = 3,
+    BigIntLikeType = 4,
+    StringLikeType = 5,
+    BooleanType = 6,
+    ArrayLikeType = 7,
+    ESSymbolType = 8,
+    Promise = 9,
+    TypeWithCallSignature = 10,
+    ObjectType = 11
+}
+export declare function getTypeReferenceSerializationKind(resolver: ReferenceResolver, typeName: Node, location: Node | undefined): TypeReferenceSerializationKind;