tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/transformers/subtree-facts.d.ts

@@ -0,0 +1,10 @@
+import { type Node, NodeVisitor } from '../ast.js';
+/** Memoized `containsTypeScript` answers for one emit. */
+export declare class TypeScriptFacts extends NodeVisitor {
+    /** The answer for each node, by node id. */
+    private readonly cache;
+    private found;
+    constructor();
+    containsTypeScript(node: Node): boolean;
+    visitNode(node: Node): boolean;
+}

package/dist/api/compiler/transformers/subtree-facts.js

@@ -0,0 +1,205 @@
+// Whether a subtree contains TypeScript-only syntax, computed as tsgo's subtree facts are.
+// Transforms skip subtrees without it; that also decides how malformed code is emitted.
+import { ClassDeclaration, ClassExpression, ConstructorDeclaration, ExportAssignment, ExportDeclaration, ExportSpecifier, FunctionDeclaration, GetAccessorDeclaration, Identifier, ImportClause, ImportEqualsDeclaration, ImportSpecifier, MethodDeclaration, NodeVisitor, ParameterDeclaration, PropertyDeclaration, SetAccessorDeclaration, VariableDeclaration, VariableStatement, ArrowFunction, FunctionExpression, CallExpression, NewExpression, TaggedTemplateExpression, ExpressionWithTypeArguments, JsxOpeningElement, JsxSelfClosingElement, HeritageClause, getModifiers, } from '../ast.js';
+import { ClusteredIntLinkTable } from '../link-tables.js';
+import { isTypeNodeKind } from '../printer/utilities.js';
+/** Memoized `containsTypeScript` answers for one emit. */
+export class TypeScriptFacts extends NodeVisitor {
+    /** The answer for each node, by node id. */
+    cache;
+    found;
+    constructor() {
+        super();
+        this.cache = new ClusteredIntLinkTable();
+        this.found = false;
+    }
+    containsTypeScript(node) {
+        const cached = this.cache.get(node.id);
+        if (cached !== 0)
+            return cached === 2 /* Answer.Yes */;
+        const own = ownFacts(node);
+        let result = (own & 1 /* Facts.TypeScript */) !== 0;
+        if (!result && (own & 2 /* Facts.Final */) === 0) {
+            const saved = this.found;
+            this.found = false;
+            node.forEachChild(this);
+            result = this.found;
+            this.found = saved;
+        }
+        this.cache.set(node.id, result ? 2 /* Answer.Yes */ : 1 /* Answer.No */);
+        return result;
+    }
+    visitNode(node) {
+        if (this.containsTypeScript(node))
+            this.found = true;
+        return this.found;
+    }
+}
+function ambient(node) {
+    const modifiers = getModifiers(node);
+    return modifiers !== undefined && (modifiers.modifierFlags & 128 /* ModifierFlags.Ambient */) !== 0;
+}
+/** TypeScript syntax of the node itself, beyond what its children contribute. */
+function ownFacts(node) {
+    const kind = node.kind;
+    if (isTypeNodeKind(kind) && kind !== 234 /* SyntaxKind.ExpressionWithTypeArguments */)
+        return 1 /* Facts.TypeScript */;
+    switch (kind) {
+        case 124 /* SyntaxKind.PublicKeyword */:
+        case 122 /* SyntaxKind.PrivateKeyword */:
+        case 123 /* SyntaxKind.ProtectedKeyword */:
+        case 148 /* SyntaxKind.ReadonlyKeyword */:
+        case 127 /* SyntaxKind.AbstractKeyword */:
+        case 137 /* SyntaxKind.DeclareKeyword */:
+        case 86 /* SyntaxKind.ConstKeyword */:
+        case 102 /* SyntaxKind.InKeyword */:
+        case 147 /* SyntaxKind.OutKeyword */:
+        case 164 /* SyntaxKind.OverrideKeyword */:
+        case 94 /* SyntaxKind.ExportKeyword */:
+        case 171 /* SyntaxKind.Decorator */:
+        case 306 /* SyntaxKind.EnumMember */:
+        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 235 /* SyntaxKind.AsExpression */:
+        case 239 /* SyntaxKind.SatisfiesExpression */:
+        case 236 /* SyntaxKind.NonNullExpression */:
+        case 217 /* SyntaxKind.TypeAssertionExpression */:
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+        case 180 /* SyntaxKind.CallSignature */:
+        case 181 /* SyntaxKind.ConstructSignature */:
+        case 182 /* SyntaxKind.IndexSignature */:
+        case 174 /* SyntaxKind.MethodSignature */:
+        case 172 /* SyntaxKind.PropertySignature */:
+        case 169 /* SyntaxKind.TypeParameter */:
+            return 1 /* Facts.TypeScript */;
+        case 244 /* SyntaxKind.VariableStatement */:
+            return node instanceof VariableStatement && ambient(node) ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
+        case 261 /* SyntaxKind.VariableDeclaration */:
+            return node instanceof VariableDeclaration && (node.exclamationToken !== undefined || node.type !== undefined)
+                ? 1 /* Facts.TypeScript */
+                : 0 /* Facts.None */;
+        case 170 /* SyntaxKind.Parameter */:
+            if (node instanceof ParameterDeclaration)
+                return (node.name instanceof Identifier && node.name.text === 'this') ||
+                    node.questionToken !== undefined ||
+                    node.type !== undefined
+                    ? 1 /* Facts.TypeScript */
+                    : 0 /* Facts.None */;
+            break;
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+            if (node instanceof FunctionDeclaration)
+                return node.body === undefined ||
+                    ambient(node) ||
+                    node.typeParameters !== undefined ||
+                    node.type !== undefined ||
+                    node.fullSignature !== undefined
+                    ? 1 /* Facts.TypeScript */
+                    : 0 /* Facts.None */;
+            break;
+        case 264 /* SyntaxKind.ClassDeclaration */:
+            if (node instanceof ClassDeclaration)
+                return ambient(node) || node.typeParameters !== undefined ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
+            break;
+        case 232 /* SyntaxKind.ClassExpression */:
+            if (node instanceof ClassExpression)
+                return ambient(node) || node.typeParameters !== undefined ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
+            break;
+        case 299 /* SyntaxKind.HeritageClause */:
+            if (node instanceof HeritageClause) {
+                if (node.token === 118 /* SyntaxKind.ImplementsKeyword */)
+                    return 1 /* Facts.TypeScript */;
+                return node.token === 95 /* SyntaxKind.ExtendsKeyword */ ? 0 /* Facts.None */ : 2 /* Facts.Final */;
+            }
+            break;
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            if (node instanceof ImportEqualsDeclaration)
+                return node.isTypeOnly || node.moduleReference.kind !== 284 /* SyntaxKind.ExternalModuleReference */
+                    ? 1 /* Facts.TypeScript */
+                    : 0 /* Facts.None */;
+            break;
+        case 277 /* SyntaxKind.ImportSpecifier */:
+            return node instanceof ImportSpecifier && node.isTypeOnly ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
+        case 274 /* SyntaxKind.ImportClause */:
+            return node instanceof ImportClause && node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */
+                ? 1 /* Facts.TypeScript */
+                : 0 /* Facts.None */;
+        case 278 /* SyntaxKind.ExportAssignment */:
+            return node instanceof ExportAssignment && node.isExportEquals ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
+        case 279 /* SyntaxKind.ExportDeclaration */:
+            return node instanceof ExportDeclaration && node.isTypeOnly ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
+        case 282 /* SyntaxKind.ExportSpecifier */:
+            return node instanceof ExportSpecifier && node.isTypeOnly ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
+        case 177 /* SyntaxKind.Constructor */:
+            if (node instanceof ConstructorDeclaration)
+                return node.body === undefined ||
+                    node.typeParameters !== undefined ||
+                    node.type !== undefined ||
+                    node.fullSignature !== undefined
+                    ? 1 /* Facts.TypeScript */
+                    : 0 /* Facts.None */;
+            break;
+        case 178 /* SyntaxKind.GetAccessor */:
+            if (node instanceof GetAccessorDeclaration)
+                return node.body === undefined ||
+                    node.typeParameters !== undefined ||
+                    node.type !== undefined ||
+                    node.fullSignature !== undefined
+                    ? 1 /* Facts.TypeScript */
+                    : 0 /* Facts.None */;
+            break;
+        case 179 /* SyntaxKind.SetAccessor */:
+            if (node instanceof SetAccessorDeclaration)
+                return node.body === undefined ||
+                    node.typeParameters !== undefined ||
+                    node.type !== undefined ||
+                    node.fullSignature !== undefined
+                    ? 1 /* Facts.TypeScript */
+                    : 0 /* Facts.None */;
+            break;
+        case 175 /* SyntaxKind.MethodDeclaration */:
+            if (node instanceof MethodDeclaration)
+                return node.body === undefined ||
+                    node.postfixToken !== undefined ||
+                    node.typeParameters !== undefined ||
+                    node.type !== undefined ||
+                    node.fullSignature !== undefined
+                    ? 1 /* Facts.TypeScript */
+                    : 0 /* Facts.None */;
+            break;
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+            return node instanceof PropertyDeclaration && (node.postfixToken !== undefined || node.type !== undefined)
+                ? 1 /* Facts.TypeScript */
+                : 0 /* Facts.None */;
+        case 220 /* SyntaxKind.ArrowFunction */:
+            return node instanceof ArrowFunction &&
+                (node.typeParameters !== undefined || node.type !== undefined || node.fullSignature !== undefined)
+                ? 1 /* Facts.TypeScript */
+                : 0 /* Facts.None */;
+        case 219 /* SyntaxKind.FunctionExpression */:
+            return node instanceof FunctionExpression &&
+                (node.typeParameters !== undefined || node.type !== undefined || node.fullSignature !== undefined)
+                ? 1 /* Facts.TypeScript */
+                : 0 /* Facts.None */;
+        case 214 /* SyntaxKind.CallExpression */:
+            return node instanceof CallExpression && node.typeArguments !== undefined ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
+        case 215 /* SyntaxKind.NewExpression */:
+            return node instanceof NewExpression && node.typeArguments !== undefined ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
+        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+            return node instanceof TaggedTemplateExpression && node.typeArguments !== undefined
+                ? 1 /* Facts.TypeScript */
+                : 0 /* Facts.None */;
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            return node instanceof ExpressionWithTypeArguments && node.typeArguments !== undefined
+                ? 1 /* Facts.TypeScript */
+                : 0 /* Facts.None */;
+        case 287 /* SyntaxKind.JsxOpeningElement */:
+            return node instanceof JsxOpeningElement && node.typeArguments !== undefined ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+            return node instanceof JsxSelfClosingElement && node.typeArguments !== undefined ? 1 /* Facts.TypeScript */ : 0 /* Facts.None */;
+    }
+    return 0 /* Facts.None */;
+}

package/dist/api/compiler/transformers/syntax-facts.d.ts

@@ -0,0 +1,52 @@
+import { type Node, NodeVisitor } from '../ast.js';
+export declare const enum SubtreeFacts {
+    None = 0,
+    ContainsTypeScript = 1,
+    ContainsJsx = 2,
+    ContainsUsing = 4,
+    ContainsLogicalAssignments = 8,
+    ContainsNullishCoalescing = 16,
+    ContainsOptionalChaining = 32,
+    ContainsMissingCatchClauseVariable = 64,
+    /** A `...` in an object literal or object pattern somewhere inside; never cleared. */
+    ContainsESObjectRestOrSpread = 128,
+    ContainsForAwaitOrAsyncGenerator = 256,
+    ContainsAnyAwait = 512,
+    ContainsExponentiationOperator = 1024,
+    ContainsLexicalThis = 2048,
+    ContainsLexicalSuper = 4096,
+    /** A `...` anywhere; cleared when leaving a binding pattern. */
+    ContainsRestOrSpread = 8192,
+    /** A `{ ...x }`; cleared when leaving most scopes. */
+    ContainsObjectRestOrSpread = 16384,
+    ContainsAwait = 32768,
+    ContainsDynamicImport = 65536,
+    ContainsClassFields = 131072,
+    ContainsDecorators = 262144,
+    ContainsIdentifier = 524288,
+    ContainsPrivateIdentifierInExpression = 1048576,
+    ContainsInvalidTemplateEscape = 2097152,
+    ContainsLexicalThisOrSuper = 6144
+}
+/** Memoized subtree facts for one emit; synthesized nodes get theirs on first use. */
+export declare class SyntaxFacts extends NodeVisitor {
+    /** The facts of each node, by node id, with `computedFacts` set. */
+    private readonly cache;
+    private collected;
+    constructor();
+    of(node: Node): SubtreeFacts;
+    has(node: Node, facts: SubtreeFacts): boolean;
+    /** Whether the subtree has a `...` in a pattern or literal. */
+    hasRestOrSpread(node: Node): boolean;
+    /** Whether the subtree has a `{ ...x }` in a pattern or literal, outside nested scopes. */
+    hasObjectRestOrSpread(node: Node): boolean;
+    /** The facts `node` contributes to its parent. */
+    propagate(node: Node | undefined): SubtreeFacts;
+    visitNode(node: Node): boolean;
+    private children;
+    private compute;
+    private bindingPattern;
+    private binaryFacts;
+    /** Whether a pattern has an object rest element, at any depth of nested assignment patterns. */
+    containsObjectRestOrSpread(node: Node): boolean;
+}

package/dist/api/compiler/transformers/syntax-facts.js

@@ -0,0 +1,258 @@
+// What syntax a subtree contains, computed as tsgo's subtree facts are. Downlevel transforms
+// skip subtrees without the syntax they lower.
+import { BindingElement, CallExpression, CatchClause, ForInOrOfStatement, Identifier, MetaProperty, NodeVisitor, NoSubstitutionTemplateLiteral, PropertyAccessExpression, TemplateHead, TemplateMiddle, TemplateTail, VariableDeclarationList, getModifiers, getName, } from '../ast.js';
+import { ClusteredIntLinkTable } from '../link-tables.js';
+import { isTypeNodeKind } from '../printer/utilities.js';
+import { getElementsOfBindingOrAssignmentPattern, getTargetOfBindingOrAssignmentElement } from './destructuring.js';
+/** Marks a computed entry of `SyntaxFacts.cache`, whose facts may be `None`. */
+const computedFacts = 1 << 30;
+/** Memoized subtree facts for one emit; synthesized nodes get theirs on first use. */
+export class SyntaxFacts extends NodeVisitor {
+    /** The facts of each node, by node id, with `computedFacts` set. */
+    cache;
+    collected;
+    constructor() {
+        super();
+        this.cache = new ClusteredIntLinkTable();
+        this.collected = 0 /* SubtreeFacts.None */;
+    }
+    of(node) {
+        const cached = this.cache.get(node.id);
+        if (cached !== 0)
+            return cached & ~computedFacts;
+        const facts = this.compute(node);
+        this.cache.set(node.id, facts | computedFacts);
+        return facts;
+    }
+    has(node, facts) {
+        return (this.of(node) & facts) !== 0;
+    }
+    /** Whether the subtree has a `...` in a pattern or literal. */
+    hasRestOrSpread(node) {
+        return this.has(node, 8192 /* SubtreeFacts.ContainsRestOrSpread */ | 16384 /* SubtreeFacts.ContainsObjectRestOrSpread */);
+    }
+    /** Whether the subtree has a `{ ...x }` in a pattern or literal, outside nested scopes. */
+    hasObjectRestOrSpread(node) {
+        return this.has(node, 16384 /* SubtreeFacts.ContainsObjectRestOrSpread */);
+    }
+    /** The facts `node` contributes to its parent. */
+    propagate(node) {
+        if (node === undefined)
+            return 0 /* SubtreeFacts.None */;
+        const kind = node.kind;
+        if (isTypeNodeKind(kind) && kind !== 234 /* SyntaxKind.ExpressionWithTypeArguments */)
+            return 1 /* SubtreeFacts.ContainsTypeScript */;
+        const facts = this.of(node);
+        switch (kind) {
+            case 220 /* SyntaxKind.ArrowFunction */:
+                return facts & ~49152 /* Exclusions.ArrowFunction */;
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 219 /* SyntaxKind.FunctionExpression */:
+            case 177 /* SyntaxKind.Constructor */:
+                return facts & ~55296 /* Exclusions.Function */;
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */:
+                return (facts & ~55296 /* Exclusions.Function */) | this.propagate(getName(node));
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+                return (facts & ~6144 /* Exclusions.Property */) | this.propagate(getName(node));
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+                return facts & ~6144 /* Exclusions.Module */;
+            case 211 /* SyntaxKind.ObjectLiteralExpression */:
+            case 262 /* SyntaxKind.VariableDeclarationList */:
+            case 300 /* SyntaxKind.CatchClause */:
+                return facts & ~16384 /* Exclusions.ObjectRestOrSpread */;
+            case 207 /* SyntaxKind.ObjectBindingPattern */:
+            case 208 /* SyntaxKind.ArrayBindingPattern */:
+                return facts & ~8192 /* Exclusions.BindingPattern */;
+        }
+        return facts;
+    }
+    visitNode(node) {
+        this.collected |= this.propagate(node);
+        return false;
+    }
+    children(node) {
+        const saved = this.collected;
+        this.collected = 0 /* SubtreeFacts.None */;
+        node.forEachChild(this);
+        const facts = this.collected;
+        this.collected = saved;
+        return facts;
+    }
+    compute(node) {
+        switch (node.kind) {
+            case 160 /* SyntaxKind.UsingKeyword */:
+                return 4 /* SubtreeFacts.ContainsUsing */;
+            case 128 /* SyntaxKind.AccessorKeyword */:
+            case 80 /* SyntaxKind.PrivateIdentifier */:
+                return 131072 /* SubtreeFacts.ContainsClassFields */;
+            case 133 /* SyntaxKind.AsyncKeyword */:
+                return 512 /* SubtreeFacts.ContainsAnyAwait */;
+            case 107 /* SyntaxKind.SuperKeyword */:
+                return 4096 /* SubtreeFacts.ContainsLexicalSuper */;
+            case 109 /* SyntaxKind.ThisKeyword */:
+                return 2048 /* SubtreeFacts.ContainsLexicalThis */;
+            case 42 /* SyntaxKind.AsteriskAsteriskToken */:
+            case 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */:
+                return 1024 /* SubtreeFacts.ContainsExponentiationOperator */;
+            case 60 /* SyntaxKind.QuestionQuestionToken */:
+                return 16 /* SubtreeFacts.ContainsNullishCoalescing */;
+            case 28 /* SyntaxKind.QuestionDotToken */:
+                return 32 /* SubtreeFacts.ContainsOptionalChaining */;
+            case 77 /* SyntaxKind.QuestionQuestionEqualsToken */:
+            case 75 /* SyntaxKind.BarBarEqualsToken */:
+            case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */:
+                return 8 /* SubtreeFacts.ContainsLogicalAssignments */;
+            case 79 /* SyntaxKind.Identifier */:
+                return 524288 /* SubtreeFacts.ContainsIdentifier */;
+            case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+                return node instanceof NoSubstitutionTemplateLiteral && invalidEscape(node.templateFlags)
+                    ? 2097152 /* SubtreeFacts.ContainsInvalidTemplateEscape */
+                    : 0 /* SubtreeFacts.None */;
+            case 15 /* SyntaxKind.TemplateHead */:
+                return node instanceof TemplateHead && invalidEscape(node.templateFlags)
+                    ? 2097152 /* SubtreeFacts.ContainsInvalidTemplateEscape */
+                    : 0 /* SubtreeFacts.None */;
+            case 16 /* SyntaxKind.TemplateMiddle */:
+                return node instanceof TemplateMiddle && invalidEscape(node.templateFlags)
+                    ? 2097152 /* SubtreeFacts.ContainsInvalidTemplateEscape */
+                    : 0 /* SubtreeFacts.None */;
+            case 17 /* SyntaxKind.TemplateTail */:
+                return node instanceof TemplateTail && invalidEscape(node.templateFlags)
+                    ? 2097152 /* SubtreeFacts.ContainsInvalidTemplateEscape */
+                    : 0 /* SubtreeFacts.None */;
+            case 171 /* SyntaxKind.Decorator */:
+                return this.children(node) | 1 /* SubtreeFacts.ContainsTypeScript */ | 262144 /* SubtreeFacts.ContainsDecorators */;
+            case 250 /* SyntaxKind.ForInStatement */:
+            case 251 /* SyntaxKind.ForOfStatement */:
+                return (this.children(node) |
+                    (node instanceof ForInOrOfStatement && node.awaitModifier !== undefined
+                        ? 256 /* SubtreeFacts.ContainsForAwaitOrAsyncGenerator */
+                        : 0 /* SubtreeFacts.None */));
+            case 254 /* SyntaxKind.ReturnStatement */:
+            case 230 /* SyntaxKind.YieldExpression */:
+                // Returns and yields in an ES2018 async generator are awaited.
+                return this.children(node) | 256 /* SubtreeFacts.ContainsForAwaitOrAsyncGenerator */;
+            case 224 /* SyntaxKind.AwaitExpression */:
+                return (this.children(node) |
+                    32768 /* SubtreeFacts.ContainsAwait */ |
+                    512 /* SubtreeFacts.ContainsAnyAwait */ |
+                    256 /* SubtreeFacts.ContainsForAwaitOrAsyncGenerator */);
+            case 300 /* SyntaxKind.CatchClause */:
+                return (this.children(node) |
+                    (node instanceof CatchClause && node.variableDeclaration === undefined
+                        ? 64 /* SubtreeFacts.ContainsMissingCatchClauseVariable */
+                        : 0 /* SubtreeFacts.None */));
+            case 262 /* SyntaxKind.VariableDeclarationList */:
+                return (this.children(node) |
+                    (node instanceof VariableDeclarationList && (node.flags & 4 /* NodeFlags.Using */) !== 0
+                        ? 4 /* SubtreeFacts.ContainsUsing */
+                        : 0 /* SubtreeFacts.None */));
+            case 207 /* SyntaxKind.ObjectBindingPattern */:
+            case 208 /* SyntaxKind.ArrayBindingPattern */:
+                return this.bindingPattern(node);
+            case 209 /* SyntaxKind.BindingElement */:
+                return (this.children(node) |
+                    (node instanceof BindingElement && node.dotDotDotToken !== undefined
+                        ? 8192 /* SubtreeFacts.ContainsRestOrSpread */
+                        : 0 /* SubtreeFacts.None */));
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+                return this.children(node) | asyncFacts(node, node.asteriskToken !== undefined);
+            case 219 /* SyntaxKind.FunctionExpression */:
+                return this.children(node) | asyncFacts(node, node.asteriskToken !== undefined);
+            case 175 /* SyntaxKind.MethodDeclaration */:
+                return this.children(node) | asyncFacts(node, node.asteriskToken !== undefined);
+            case 220 /* SyntaxKind.ArrowFunction */:
+                return this.children(node) | asyncFacts(node, false);
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+                return this.children(node) | 131072 /* SubtreeFacts.ContainsClassFields */;
+            case 227 /* SyntaxKind.BinaryExpression */:
+                return this.children(node) | this.binaryFacts(node);
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+                return (this.children(node) |
+                    (node instanceof PropertyAccessExpression && !(node.name instanceof Identifier)
+                        ? 1048576 /* SubtreeFacts.ContainsPrivateIdentifierInExpression */
+                        : 0 /* SubtreeFacts.None */));
+            case 214 /* SyntaxKind.CallExpression */:
+                return (this.children(node) |
+                    (node instanceof CallExpression && node.expression.kind === 101 /* SyntaxKind.ImportKeyword */
+                        ? 65536 /* SubtreeFacts.ContainsDynamicImport */
+                        : 0 /* SubtreeFacts.None */));
+            case 237 /* SyntaxKind.MetaProperty */:
+                return node instanceof MetaProperty ? this.propagate(node.name) & ~524288 /* SubtreeFacts.ContainsIdentifier */ : 0;
+            case 231 /* SyntaxKind.SpreadElement */:
+                return this.children(node) | 8192 /* SubtreeFacts.ContainsRestOrSpread */;
+            case 305 /* SyntaxKind.SpreadAssignment */:
+                return (this.children(node) | 128 /* SubtreeFacts.ContainsESObjectRestOrSpread */ | 16384 /* SubtreeFacts.ContainsObjectRestOrSpread */);
+            case 285 /* SyntaxKind.JsxElement */:
+            case 293 /* SyntaxKind.JsxAttributes */:
+            case 296 /* SyntaxKind.JsxNamespacedName */:
+            case 287 /* SyntaxKind.JsxOpeningElement */:
+            case 286 /* SyntaxKind.JsxSelfClosingElement */:
+            case 289 /* SyntaxKind.JsxFragment */:
+            case 290 /* SyntaxKind.JsxOpeningFragment */:
+            case 291 /* SyntaxKind.JsxClosingFragment */:
+            case 292 /* SyntaxKind.JsxAttribute */:
+            case 294 /* SyntaxKind.JsxSpreadAttribute */:
+            case 288 /* SyntaxKind.JsxClosingElement */:
+            case 295 /* SyntaxKind.JsxExpression */:
+            case 11 /* SyntaxKind.JsxText */:
+                return this.children(node) | 2 /* SubtreeFacts.ContainsJsx */;
+        }
+        return this.children(node);
+    }
+    bindingPattern(node) {
+        const elements = node.elements.nodes;
+        const object = node.kind === 207 /* SyntaxKind.ObjectBindingPattern */;
+        let facts = 0 /* SubtreeFacts.None */;
+        for (const child of elements) {
+            let element = this.propagate(child);
+            if ((element & 8192 /* SubtreeFacts.ContainsRestOrSpread */) !== 0) {
+                element &= ~8192 /* SubtreeFacts.ContainsRestOrSpread */;
+                if (object)
+                    element |= 16384 /* SubtreeFacts.ContainsObjectRestOrSpread */ | 128 /* SubtreeFacts.ContainsESObjectRestOrSpread */;
+            }
+            facts |= element;
+        }
+        return facts;
+    }
+    binaryFacts(node) {
+        const operator = node.operatorToken.kind;
+        if (operator === 102 /* SyntaxKind.InKeyword */ && node.left.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+            return 131072 /* SubtreeFacts.ContainsClassFields */ | 1048576 /* SubtreeFacts.ContainsPrivateIdentifierInExpression */;
+        if (operator === 63 /* SyntaxKind.EqualsToken */ &&
+            (node.left.kind === 211 /* SyntaxKind.ObjectLiteralExpression */ || node.left.kind === 210 /* SyntaxKind.ArrayLiteralExpression */) &&
+            this.containsObjectRestOrSpread(node.left))
+            return 16384 /* SubtreeFacts.ContainsObjectRestOrSpread */;
+        return 0 /* SubtreeFacts.None */;
+    }
+    /** Whether a pattern has an object rest element, at any depth of nested assignment patterns. */
+    containsObjectRestOrSpread(node) {
+        const facts = this.of(node);
+        if ((facts & 16384 /* SubtreeFacts.ContainsObjectRestOrSpread */) !== 0)
+            return true;
+        if ((facts & 128 /* SubtreeFacts.ContainsESObjectRestOrSpread */) === 0)
+            return false;
+        // Nested spreads, as in `{ x: { a, ...b } = foo } = c`.
+        const elements = getElementsOfBindingOrAssignmentPattern(node);
+        for (const element of elements) {
+            const target = getTargetOfBindingOrAssignmentElement(element);
+            if (target !== undefined &&
+                (target.kind === 211 /* SyntaxKind.ObjectLiteralExpression */ || target.kind === 210 /* SyntaxKind.ArrayLiteralExpression */) &&
+                this.containsObjectRestOrSpread(target))
+                return true;
+        }
+        return false;
+    }
+}
+function invalidEscape(flags) {
+    return (flags & 2048 /* TokenFlags.ContainsInvalidEscape */) !== 0;
+}
+function asyncFacts(node, generator) {
+    const modifiers = getModifiers(node);
+    if (modifiers === undefined || (modifiers.modifierFlags & 1024 /* ModifierFlags.Async */) === 0)
+        return 0 /* SubtreeFacts.None */;
+    return generator ? 256 /* SubtreeFacts.ContainsForAwaitOrAsyncGenerator */ : 512 /* SubtreeFacts.ContainsAnyAwait */;
+}

package/dist/api/compiler/transformers/tagged-template.d.ts

@@ -0,0 +1,17 @@
+import { type Node } from '../ast.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import { type SyntaxFacts } from './syntax-facts.js';
+import { Transformer } from './transformer.js';
+export declare class TaggedTemplateTransformer extends Transformer {
+    readonly facts: SyntaxFacts;
+    private file;
+    /** `templateObject` variables, declared at the end of a module. */
+    private declarations;
+    constructor(context: EmitContext, facts: SyntaxFacts);
+    visit(node: Node): Node | undefined;
+    private visitSourceFile;
+    private visitTaggedTemplate;
+    private cookedString;
+    /** The raw text of a template literal part, with line terminators normalized to `\n`. */
+    private rawString;
+}