tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/transformers/logical-assignment.js

@@ -0,0 +1,62 @@
+// Lowers `a ||= b`, `a &&= b` and `a ??= b` to `a || (a = b)` and so on (ES2021).
+import { BinaryExpression, ElementAccessExpression, PropertyAccessExpression } from '../ast.js';
+import { skipParentheses } from '../binder-utilities.js';
+import { isSimpleCopiableExpression } from './destructuring.js';
+import { Transformer } from './transformer.js';
+export class LogicalAssignmentTransformer extends Transformer {
+    facts;
+    constructor(context, facts) {
+        super(context);
+        this.facts = facts;
+    }
+    visit(node) {
+        if (!this.facts.has(node, 8 /* SubtreeFacts.ContainsLogicalAssignments */))
+            return node;
+        if (node instanceof BinaryExpression) {
+            const operator = logicalOperatorOf(node.operatorToken.kind);
+            if (operator !== 0 /* SyntaxKind.Unknown */)
+                return this.visitLogicalAssignment(node, operator);
+        }
+        return this.visitEachChild(node);
+    }
+    visitLogicalAssignment(node, operator) {
+        const factory = this.factory;
+        const visited = skipParentheses(this.visitNode(node.left));
+        let left = visited;
+        let target = visited;
+        const right = skipParentheses(this.visitNode(node.right));
+        if (visited instanceof PropertyAccessExpression) {
+            const object = this.copiableObject(visited.expression);
+            target = factory.createPropertyAccessExpression(object, visited.name);
+            left = factory.createPropertyAccessExpression(this.assignedObject(object, visited.expression), visited.name);
+        }
+        else if (visited instanceof ElementAccessExpression) {
+            const object = this.copiableObject(visited.expression);
+            const argument = this.copiableObject(visited.argumentExpression);
+            target = factory.createElementAccessExpression(object, argument);
+            left = factory.createElementAccessExpression(this.assignedObject(object, visited.expression), this.assignedObject(argument, visited.argumentExpression));
+        }
+        return factory.createBinaryExpression(left, operator, factory.createParenthesizedExpression(factory.createAssignment(target, right)));
+    }
+    /** `expression`, or a temporary to hold it when it can't be evaluated twice. */
+    copiableObject(expression) {
+        if (isSimpleCopiableExpression(expression))
+            return expression;
+        return this.context.addVariableDeclaration(this.factory.createTempVariable(0));
+    }
+    /** `expression`, or its assignment to the temporary `copy` holding it. */
+    assignedObject(copy, expression) {
+        return copy === expression ? expression : this.factory.createAssignment(copy, expression);
+    }
+}
+function logicalOperatorOf(kind) {
+    switch (kind) {
+        case 75 /* SyntaxKind.BarBarEqualsToken */:
+            return 56 /* SyntaxKind.BarBarToken */;
+        case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */:
+            return 55 /* SyntaxKind.AmpersandAmpersandToken */;
+        case 77 /* SyntaxKind.QuestionQuestionEqualsToken */:
+            return 60 /* SyntaxKind.QuestionQuestionToken */;
+    }
+    return 0 /* SyntaxKind.Unknown */;
+}

package/dist/api/compiler/transformers/module-utilities.d.ts

@@ -0,0 +1,9 @@
+import { type Node, StringLiteral } from '../ast.js';
+import type { CompilerOptions } from '../options.js';
+import type { EmitContext } from '../printer/emit-context.js';
+/** The module name of an import, export or `import()` as written in output, or undefined. */
+export declare function getExternalModuleNameLiteral(context: EmitContext, node: Node): StringLiteral | undefined;
+/** The arguments of the `require` call for an import: its rewritten module name. */
+export declare function createRequireCallArguments(context: EmitContext, node: Node, options: CompilerOptions): Node[];
+/** With `rewriteRelativeImportExtensions`, `./a.ts` becomes `./a.js`. */
+export declare function rewriteModuleSpecifier(context: EmitContext, node: Node, options: CompilerOptions): Node;

package/dist/api/compiler/transformers/module-utilities.js

@@ -0,0 +1,36 @@
+// Module specifiers as module transforms write them.
+import { StringLiteral } from '../ast.js';
+import { getExternalModuleName } from '../ast-utilities.js';
+import { getOutputExtension } from '../output-paths.js';
+import { changeExtension, hasTSFileExtension, isDeclarationFileName, pathIsRelative } from '../path.js';
+/** The module name of an import, export or `import()` as written in output, or undefined. */
+export function getExternalModuleNameLiteral(context, node) {
+    const name = getExternalModuleName(node);
+    if (!(name instanceof StringLiteral))
+        return undefined;
+    return context.factory.createStringLiteral(name.text, 0 /* TokenFlags.None */);
+}
+/** The arguments of the `require` call for an import: its rewritten module name. */
+export function createRequireCallArguments(context, node, options) {
+    const name = getExternalModuleNameLiteral(context, node);
+    return name === undefined ? [] : [rewriteModuleSpecifier(context, name, options)];
+}
+/** With `rewriteRelativeImportExtensions`, `./a.ts` becomes `./a.js`. */
+export function rewriteModuleSpecifier(context, node, options) {
+    if (!(node instanceof StringLiteral) || !shouldRewriteModuleSpecifier(node.text, options))
+        return node;
+    const text = node.text;
+    const updatedText = changeExtension(text, getOutputExtension(text, options.jsx));
+    if (updatedText === text)
+        return node;
+    const updated = context.factory.createStringLiteral(updatedText, node.tokenFlags);
+    context.setOriginal(updated, node);
+    context.assignCommentAndSourceMapRanges(updated, node);
+    return updated;
+}
+function shouldRewriteModuleSpecifier(specifier, options) {
+    return (options.rewriteRelativeImportExtensions === true &&
+        pathIsRelative(specifier) &&
+        !isDeclarationFileName(specifier) &&
+        hasTSFileExtension(specifier));
+}

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

@@ -0,0 +1,49 @@
+import { type Node } from '../ast.js';
+import { type CompilerOptions, ModuleKind } from '../options.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import type { EmitResolver } from './emit-resolver.js';
+import { Transformer } from './transformer.js';
+/** Decides the module format each file is emitted in, from its extension and the nearest package.json. */
+export declare abstract class ModuleFormatHost {
+    abstract getEmitModuleFormat(fileName: string): ModuleKind;
+}
+export declare class UseStrictTransformer extends Transformer {
+    readonly options: CompilerOptions;
+    readonly formats: ModuleFormatHost;
+    constructor(context: EmitContext, options: CompilerOptions, formats: ModuleFormatHost);
+    visit(node: Node): Node | undefined;
+}
+/** The module transform for `module`: ES modules, CommonJS, or the format each file implies. */
+export declare function createModuleTransformer(context: EmitContext, options: CompilerOptions, resolver: EmitResolver, formats: ModuleFormatHost): Transformer;
+/** Emits each file as an ES module or as CommonJS, by its format. */
+export declare class ImpliedModuleTransformer extends Transformer {
+    readonly options: CompilerOptions;
+    readonly resolver: EmitResolver;
+    readonly formats: ModuleFormatHost;
+    private esm;
+    private commonjs;
+    constructor(context: EmitContext, options: CompilerOptions, resolver: EmitResolver, formats: ModuleFormatHost);
+    visit(node: Node): Node | undefined;
+}
+/** ECMAScript module output: drops or rewrites `import x = require()` and `export =`, and keeps files modules. */
+export declare class ESModuleTransformer extends Transformer {
+    readonly options: CompilerOptions;
+    readonly formats: ModuleFormatHost;
+    private currentSourceFile;
+    /** `import { createRequire } from "module"` and `const __require = ...`, once a file needs them. */
+    private requireStatements;
+    private requireHelperName;
+    constructor(context: EmitContext, options: CompilerOptions, formats: ModuleFormatHost);
+    visit(node: Node): Node | undefined;
+    private visitSourceFile;
+    /** The statements declaring `__require`, if the file needed them. */
+    private getRequireStatements;
+    private visitImportDeclaration;
+    /** In node16+ ES modules, `import x = require("m")` becomes a call of a `createRequire` require. */
+    private visitImportEqualsDeclaration;
+    private visitExportAssignment;
+    private visitExportDeclaration;
+    private visitCallExpression;
+    private importAttributes;
+    private createRequireCall;
+}

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

@@ -0,0 +1,296 @@
+// `"use strict"` prologues and module output: ECMAScript modules, CommonJS, or each file in the
+// format its extension and package.json imply.
+import { CallExpression, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExternalModuleReference, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, MetaProperty, NamedExports, NamedImports, NamespaceExport, NamespaceImport, NodeList, SourceFile, StringLiteral, NoSubstitutionTemplateLiteral, Identifier, } from '../ast.js';
+import { isAnyImportOrReExport, isImportCall, isInJSFile, isRequireCall } from '../ast-utilities.js';
+import { JsxEmit, ModuleKind, getEmitModuleKind, getIsolatedModules } from '../options.js';
+import { isPrologueDirective } from '../printer/utilities.js';
+import { CommonJSModuleTransformer } from './commonjs-module.js';
+import { createExternalHelpersImportDeclarationIfNeeded } from './external-module-info.js';
+import { createRequireCallArguments, rewriteModuleSpecifier } from './module-utilities.js';
+import { Transformer } from './transformer.js';
+import { hasSyntacticModifier, isExternalModule, singleOrMany } from './utilities.js';
+/** Decides the module format each file is emitted in, from its extension and the nearest package.json. */
+export class ModuleFormatHost {
+}
+export class UseStrictTransformer extends Transformer {
+    options;
+    formats;
+    constructor(context, options, formats) {
+        super(context);
+        this.options = options;
+        this.formats = formats;
+    }
+    visit(node) {
+        if (!(node instanceof SourceFile) || node.scriptKind === 6 /* ScriptKind.JSON */)
+            return node;
+        const moduleKind = getEmitModuleKind(this.options);
+        // ES modules are always strict.
+        if (isExternalModule(node) &&
+            moduleKind >= ModuleKind.ES2015 &&
+            (moduleKind === ModuleKind.Preserve || this.formats.getEmitModuleFormat(node.fileName) >= ModuleKind.ES2015))
+            return node;
+        const statements = node.statements.nodes;
+        const first = statements.length > 0 ? statements[0] : undefined;
+        if (first instanceof ExpressionStatement &&
+            first.expression instanceof StringLiteral &&
+            first.expression.text === 'use strict')
+            return node;
+        const factory = this.factory;
+        const useStrict = factory.createExpressionStatement(factory.createStringLiteral('use strict', 0 /* TokenFlags.None */));
+        return factory.updateSourceFile(node, new NodeList(node.statements.pos, node.statements.end, [useStrict].concat(statements)), node.endOfFileToken);
+    }
+}
+/** The module transform for `module`: ES modules, CommonJS, or the format each file implies. */
+export function createModuleTransformer(context, options, resolver, formats) {
+    switch (getEmitModuleKind(options)) {
+        case ModuleKind.Preserve:
+            // ES module output also keeps CommonJS syntax for `module: preserve`.
+            return new ESModuleTransformer(context, options, formats);
+        case ModuleKind.ESNext:
+        case ModuleKind.ES2022:
+        case ModuleKind.ES2020:
+        case ModuleKind.ES2015:
+        case ModuleKind.Node20:
+        case ModuleKind.Node18:
+        case ModuleKind.Node16:
+        case ModuleKind.NodeNext:
+        case ModuleKind.CommonJS:
+            return new ImpliedModuleTransformer(context, options, resolver, formats);
+    }
+    return new CommonJSModuleTransformer(context, options, resolver, formats);
+}
+/** Emits each file as an ES module or as CommonJS, by its format. */
+export class ImpliedModuleTransformer extends Transformer {
+    options;
+    resolver;
+    formats;
+    esm;
+    commonjs;
+    constructor(context, options, resolver, formats) {
+        super(context);
+        this.options = options;
+        this.resolver = resolver;
+        this.formats = formats;
+        this.esm = undefined;
+        this.commonjs = undefined;
+    }
+    visit(node) {
+        if (!(node instanceof SourceFile) || node.isDeclarationFile)
+            return node;
+        if (this.formats.getEmitModuleFormat(node.fileName) >= ModuleKind.ES2015) {
+            if (this.esm === undefined)
+                this.esm = new ESModuleTransformer(this.context, this.options, this.formats);
+            return this.esm.transformSourceFile(node);
+        }
+        if (this.commonjs === undefined)
+            this.commonjs = new CommonJSModuleTransformer(this.context, this.options, this.resolver, this.formats);
+        return this.commonjs.transformSourceFile(node);
+    }
+}
+/** ECMAScript module output: drops or rewrites `import x = require()` and `export =`, and keeps files modules. */
+export class ESModuleTransformer extends Transformer {
+    options;
+    formats;
+    currentSourceFile;
+    /** `import { createRequire } from "module"` and `const __require = ...`, once a file needs them. */
+    requireStatements;
+    requireHelperName;
+    constructor(context, options, formats) {
+        super(context);
+        this.options = options;
+        this.formats = formats;
+        this.currentSourceFile = undefined;
+        this.requireStatements = undefined;
+        this.requireHelperName = undefined;
+    }
+    visit(node) {
+        switch (node.kind) {
+            case 307 /* SyntaxKind.SourceFile */:
+                if (node instanceof SourceFile)
+                    return this.visitSourceFile(node);
+                break;
+            case 273 /* SyntaxKind.ImportDeclaration */:
+                if (node instanceof ImportDeclaration)
+                    return this.visitImportDeclaration(node);
+                break;
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+                if (node instanceof ImportEqualsDeclaration)
+                    return this.visitImportEqualsDeclaration(node);
+                break;
+            case 278 /* SyntaxKind.ExportAssignment */:
+                if (node instanceof ExportAssignment)
+                    return this.visitExportAssignment(node);
+                break;
+            case 279 /* SyntaxKind.ExportDeclaration */:
+                if (node instanceof ExportDeclaration)
+                    return this.visitExportDeclaration(node);
+                break;
+            case 214 /* SyntaxKind.CallExpression */:
+                if (node instanceof CallExpression)
+                    return this.visitCallExpression(node);
+                break;
+        }
+        return this.visitEachChild(node);
+    }
+    visitSourceFile(node) {
+        if (node.isDeclarationFile || !(isExternalModule(node) || getIsolatedModules(this.options)))
+            return node;
+        const factory = this.factory;
+        const context = this.context;
+        this.currentSourceFile = node;
+        this.requireStatements = undefined;
+        this.requireHelperName = undefined;
+        const visited = this.visitEachChild(node);
+        let result = visited instanceof SourceFile ? visited : node;
+        const helpers = context.readEmitHelpers();
+        for (let i = 0; i < helpers.length; i++)
+            context.addEmitHelper(result, helpers[i]);
+        const helpersImport = createExternalHelpersImportDeclarationIfNeeded(context, result, this.options, this.formats.getEmitModuleFormat(node.fileName));
+        const requireStatements = this.getRequireStatements();
+        if (helpersImport !== undefined || requireStatements !== undefined) {
+            const current = result.statements.nodes;
+            let end = 0;
+            while (end < current.length && isPrologueDirective(current[end]))
+                end++;
+            while (end < current.length &&
+                !isPrologueDirective(current[end]) &&
+                (context.getEmitFlags(current[end]) & 65536 /* EmitFlags.CustomPrologue */) !== 0)
+                end++;
+            const statements = current.slice(0, end);
+            if (helpersImport !== undefined) {
+                // Visited so that `import tslib = require("tslib")` becomes `const tslib = require("tslib")`.
+                const visitedImport = this.visitNode(helpersImport);
+                if (visitedImport !== undefined)
+                    statements.push(visitedImport);
+            }
+            if (requireStatements !== undefined)
+                for (let i = 0; i < requireStatements.length; i++)
+                    statements.push(requireStatements[i]);
+            for (let i = end; i < current.length; i++)
+                statements.push(current[i]);
+            result = factory.updateSourceFile(result, new NodeList(result.statements.pos, result.statements.end, statements), node.endOfFileToken);
+        }
+        if (isExternalModule(result) && getEmitModuleKind(this.options) !== ModuleKind.Preserve) {
+            const statements = result.statements.nodes;
+            let hasIndicator = false;
+            for (let i = 0; i < statements.length && !hasIndicator; i++)
+                hasIndicator = isExternalModuleIndicator(statements[i]);
+            if (!hasIndicator) {
+                const emptyExport = factory.created(new ExportDeclaration(undefined, false, factory.created(new NamedExports(factory.createNodeList([]))), undefined, undefined));
+                result = factory.updateSourceFile(result, new NodeList(result.statements.pos, result.statements.end, statements.concat([emptyExport])), node.endOfFileToken);
+            }
+        }
+        this.requireStatements = undefined;
+        this.requireHelperName = undefined;
+        this.currentSourceFile = undefined;
+        return result;
+    }
+    /** The statements declaring `__require`, if the file needed them. */
+    getRequireStatements() {
+        return this.requireStatements;
+    }
+    visitImportDeclaration(node) {
+        if (this.options.rewriteRelativeImportExtensions !== true)
+            return node;
+        const clause = this.visitNode(node.importClause);
+        return this.factory.updateImportDeclaration(node, undefined, clause instanceof ImportClause ? clause : undefined, rewriteModuleSpecifier(this.context, node.moduleSpecifier, this.options), this.importAttributes(node.attributes));
+    }
+    /** In node16+ ES modules, `import x = require("m")` becomes a call of a `createRequire` require. */
+    visitImportEqualsDeclaration(node) {
+        if (getEmitModuleKind(this.options) < ModuleKind.Node16)
+            return undefined;
+        if (!(node.moduleReference instanceof ExternalModuleReference))
+            return node;
+        const factory = this.factory;
+        const statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList([
+            factory.createVariableDeclaration(factory.cloneIdentifier(node.name), undefined, undefined, this.createRequireCall(node)),
+        ]), 2 /* NodeFlags.Const */));
+        this.context.setOriginal(statement, node);
+        this.context.assignCommentAndSourceMapRanges(statement, node);
+        const statements = [statement];
+        if (hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
+            statements.push(factory.created(new ExportDeclaration(undefined, false, factory.created(new NamedExports(factory.createNodeList([
+                factory.created(new ExportSpecifier(false, undefined, factory.cloneIdentifier(node.name))),
+            ]))), undefined, undefined)));
+        return singleOrMany(statements, factory);
+    }
+    visitExportAssignment(node) {
+        if (!node.isExportEquals)
+            return this.visitEachChild(node);
+        // `export =` isn't valid in ES modules; `module: preserve` keeps it as CommonJS.
+        if (getEmitModuleKind(this.options) !== ModuleKind.Preserve)
+            return undefined;
+        const factory = this.factory;
+        const statement = factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier('module'), factory.createIdentifier('exports')), this.visitNode(node.expression)));
+        this.context.setOriginal(statement, node);
+        return statement;
+    }
+    visitExportDeclaration(node) {
+        if (node.moduleSpecifier === undefined)
+            return node;
+        const factory = this.factory;
+        const specifier = rewriteModuleSpecifier(this.context, node.moduleSpecifier, this.options);
+        const clause = node.exportClause;
+        const module = this.options.module;
+        if ((module !== undefined && module > ModuleKind.ES2015) || !(clause instanceof NamespaceExport))
+            return factory.updateExportDeclaration(node, undefined, false, clause, specifier, this.importAttributes(node.attributes));
+        // ES2015 has no `export * as ns`: import the namespace and export it.
+        const name = clause.name;
+        const generated = factory.createGeneratedNameForNode(name, 0, '', '');
+        const importDeclaration = factory.created(new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, undefined, factory.created(new ImportClause(undefined, undefined, factory.created(new NamespaceImport(generated)))), specifier, this.importAttributes(node.attributes)));
+        this.context.setOriginal(importDeclaration, clause);
+        const exportDeclaration = name instanceof Identifier && name.text === 'default'
+            ? factory.created(new ExportAssignment(undefined, false, undefined, generated))
+            : factory.created(new ExportDeclaration(undefined, false, factory.created(new NamedExports(factory.createNodeList([factory.created(new ExportSpecifier(false, generated, name))]))), undefined, undefined));
+        this.context.setOriginal(exportDeclaration, node);
+        return singleOrMany([importDeclaration, exportDeclaration], factory);
+    }
+    visitCallExpression(node) {
+        const args = node.arguments.nodes;
+        if (this.options.rewriteRelativeImportExtensions !== true ||
+            args.length === 0 ||
+            !(isImportCall(node) || (isInJSFile(node) && isRequireCall(node, false))))
+            return this.visitEachChild(node);
+        const factory = this.factory;
+        const first = args[0];
+        const argument = first instanceof StringLiteral || first instanceof NoSubstitutionTemplateLiteral
+            ? rewriteModuleSpecifier(this.context, first, this.options)
+            : factory.createRewriteRelativeImportExtensionsHelper(first, this.options.jsx === JsxEmit.Preserve);
+        const rest = this.visitArray(args.slice(1));
+        return factory.updateCallExpression(node, this.visitNode(node.expression), node.questionDotToken, undefined, new NodeList(node.arguments.pos, node.arguments.end, [argument].concat(rest)), node.flags);
+    }
+    importAttributes(node) {
+        const visited = this.visitNode(node);
+        return visited instanceof ImportAttributes ? visited : undefined;
+    }
+    createRequireCall(node) {
+        const factory = this.factory;
+        const args = createRequireCallArguments(this.context, node, this.options);
+        if (getEmitModuleKind(this.options) === ModuleKind.Preserve)
+            return factory.createCallExpression(factory.createIdentifier('require'), args);
+        let helperName = this.requireHelperName;
+        if (helperName === undefined) {
+            const flags = 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */;
+            // import { createRequire as _createRequire } from "module";
+            const createRequireName = factory.createUniqueName('_createRequire', flags);
+            const importStatement = factory.created(new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, undefined, factory.created(new ImportClause(undefined, undefined, factory.created(new NamedImports(factory.createNodeList([
+                factory.created(new ImportSpecifier(false, factory.createIdentifier('createRequire'), createRequireName)),
+            ]))))), factory.createStringLiteral('module', 0 /* TokenFlags.None */), undefined));
+            this.context.addEmitFlags(importStatement, 65536 /* EmitFlags.CustomPrologue */);
+            // const __require = _createRequire(import.meta.url);
+            helperName = factory.createUniqueName('__require', flags);
+            const requireStatement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList([
+                factory.createVariableDeclaration(helperName, undefined, undefined, factory.createCallExpression(factory.cloneIdentifier(createRequireName), [
+                    factory.createPropertyAccessExpression(factory.created(new MetaProperty(101 /* SyntaxKind.ImportKeyword */, factory.createIdentifier('meta'))), factory.createIdentifier('url')),
+                ])),
+            ]), 2 /* NodeFlags.Const */));
+            this.context.addEmitFlags(requireStatement, 65536 /* EmitFlags.CustomPrologue */);
+            this.requireStatements = [importStatement, requireStatement];
+            this.requireHelperName = helperName;
+        }
+        return factory.createCallExpression(factory.cloneIdentifier(helperName), args);
+    }
+}
+function isExternalModuleIndicator(node) {
+    return (isAnyImportOrReExport(node) || node instanceof ExportAssignment || hasSyntacticModifier(node, 32 /* ModifierFlags.Export */));
+}

package/dist/api/compiler/transformers/named-evaluation.d.ts

@@ -0,0 +1,26 @@
+import { ClassStaticBlockDeclaration, type Node } from '../ast.js';
+import type { EmitContext } from '../printer/emit-context.js';
+/** Further narrows which anonymous function definitions a transform names. */
+export declare abstract class AnonymousFunctionFilter {
+    abstract accepts(node: Node): boolean;
+}
+/** A `static {}` block holding only `__setFunctionName(this, name)` for the block's assigned name. */
+export declare function isClassNamedEvaluationHelperBlock(context: EmitContext, node: Node): boolean;
+/** Whether a class has a NamedEvaluation helper block. */
+export declare function classHasExplicitlyAssignedName(context: EmitContext, node: Node): boolean;
+export declare function classHasDeclaredOrExplicitlyAssignedName(context: EmitContext, node: Node): boolean;
+/** https://tc39.es/ecma262/#sec-isanonymousfunctiondefinition */
+export declare function isAnonymousFunctionDefinition(context: EmitContext, node: Node | undefined, filter: AnonymousFunctionFilter | undefined): boolean;
+/** Whether `node` may give an assigned name to a class, function or arrow function. */
+export declare function isNamedEvaluationSource(node: Node): boolean;
+/** Whether `node` assigns a name to an anonymous function definition accepted by `filter`. */
+export declare function isNamedEvaluation(context: EmitContext, node: Node, filter: AnonymousFunctionFilter | undefined): boolean;
+/** `static { __setFunctionName(this, assignedName); }` for setting a class name at runtime. */
+export declare function createClassNamedEvaluationHelperBlock(context: EmitContext, assignedName: Node, thisExpression: Node | undefined): ClassStaticBlockDeclaration;
+/** Adds a NamedEvaluation helper block to a class, after its `_classThis` block, unless it has one. */
+export declare function injectClassNamedEvaluationHelperBlockIfMissing(context: EmitContext, node: Node, assignedName: Node, thisExpression: Node | undefined): Node;
+/**
+ * Transforms a NamedEvaluation source so its anonymous class or function gets its name
+ * explicitly; `assignedNameText` overrides the name.
+ */
+export declare function transformNamedEvaluation(context: EmitContext, node: Node, ignoreEmptyStringLiteral: boolean, assignedNameText: string): Node;