tsc-ts 0.0.4 → 0.0.5

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

@@ -0,0 +1,11 @@
+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 ExponentiationTransformer extends Transformer {
+    readonly facts: SyntaxFacts;
+    constructor(context: EmitContext, facts: SyntaxFacts);
+    visit(node: Node): Node | undefined;
+    private pow;
+    private visitAssignment;
+}

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

@@ -0,0 +1,76 @@
+// Lowers `**` and `**=` to `Math.pow` (ES2016).
+import { BinaryExpression, ElementAccessExpression, PropertyAccessExpression } from '../ast.js';
+import { Transformer } from './transformer.js';
+export class ExponentiationTransformer extends Transformer {
+    facts;
+    constructor(context, facts) {
+        super(context);
+        this.facts = facts;
+    }
+    visit(node) {
+        if (!this.facts.has(node, 1024 /* SubtreeFacts.ContainsExponentiationOperator */))
+            return node;
+        if (node instanceof BinaryExpression) {
+            const operator = node.operatorToken.kind;
+            if (operator === 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */)
+                return this.visitAssignment(node);
+            if (operator === 42 /* SyntaxKind.AsteriskAsteriskToken */) {
+                const left = this.visitNode(node.left);
+                const right = this.visitNode(node.right);
+                return this.pow(left, right, node);
+            }
+        }
+        return this.visitEachChild(node);
+    }
+    pow(value, exponent, node) {
+        const call = this.factory.createGlobalMethodCall('Math', 'pow', [value, exponent]);
+        call.pos = node.pos;
+        call.end = node.end;
+        return call;
+    }
+    visitAssignment(node) {
+        const factory = this.factory;
+        const context = this.context;
+        const left = this.visitNode(node.left);
+        const right = this.visitNode(node.right);
+        let target;
+        let value;
+        if (left instanceof ElementAccessExpression) {
+            // `a[x] **= b` -> `(_a = a)[_x = x] = Math.pow(_a[_x], b)`
+            const object = context.addVariableDeclaration(factory.createTempVariable(0));
+            const argument = context.addVariableDeclaration(factory.createTempVariable(0));
+            const objectAssignment = factory.createAssignment(object, left.expression);
+            objectAssignment.pos = left.expression.pos;
+            objectAssignment.end = left.expression.end;
+            const argumentAssignment = factory.createAssignment(argument, left.argumentExpression);
+            argumentAssignment.pos = left.argumentExpression.pos;
+            argumentAssignment.end = left.argumentExpression.end;
+            target = factory.createElementAccessExpression(objectAssignment, argumentAssignment);
+            value = factory.createElementAccessExpression(object, argument);
+            value.pos = left.pos;
+            value.end = left.end;
+        }
+        else if (left instanceof PropertyAccessExpression) {
+            // `a.x **= b` -> `(_a = a).x = Math.pow(_a.x, b)`
+            const object = context.addVariableDeclaration(factory.createTempVariable(0));
+            const assignment = factory.createAssignment(object, left.expression);
+            assignment.pos = left.expression.pos;
+            assignment.end = left.expression.end;
+            target = factory.createPropertyAccessExpression(assignment, left.name);
+            target.pos = left.pos;
+            target.end = left.end;
+            value = factory.createPropertyAccessExpression(object, left.name);
+            value.pos = left.pos;
+            value.end = left.end;
+        }
+        else {
+            // `a **= b` -> `a = Math.pow(a, b)`
+            target = left;
+            value = left;
+        }
+        const result = factory.createAssignment(target, this.pow(value, right, node));
+        result.pos = node.pos;
+        result.end = node.end;
+        return result;
+    }
+}

package/dist/api/compiler/transformers/external-module-info.d.ts

@@ -0,0 +1,35 @@
+import { ExportAssignment, ExportSpecifier, FunctionDeclaration, ImportDeclaration, type Node, type SourceFile } 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';
+export declare class ExternalModuleInfo {
+    /** Imports and re-exports of other modules. */
+    readonly externalImports: Node[];
+    /** Export specifiers by local name, excluding re-exports. */
+    readonly exportSpecifiers: Map<string, ExportSpecifier[]>;
+    /** The export names of each local declaration. */
+    readonly exportedBindings: Map<Node, Node[]>;
+    /** Every exported name, except those of exported function declarations. */
+    readonly exportedNames: Node[];
+    /** Exported function declarations, in order. */
+    readonly exportedFunctions: FunctionDeclaration[];
+    exportEquals: ExportAssignment | undefined;
+    hasExportStarsToExportValues: boolean;
+    constructor();
+    getExportedBindings(declaration: Node): Node[] | undefined;
+}
+export declare function collectExternalModuleInfo(file: SourceFile, context: EmitContext, resolver: EmitResolver): ExternalModuleInfo;
+export declare function moduleExportNameText(name: Node): string;
+/** `import * as ns` (or `export * as ns`), else undefined. */
+export declare function getNamespaceDeclarationNode(node: Node): Node | undefined;
+export declare function isDefaultImport(node: Node): boolean;
+export declare function containsDefaultReference(node: Node | undefined): boolean;
+export declare function getImportNeedsImportStarHelper(node: ImportDeclaration): boolean;
+export declare function getImportNeedsImportDefaultHelper(node: ImportDeclaration): boolean;
+/**
+ * With `importHelpers`, the import of the helpers a module uses: `import tslib = require("tslib")`
+ * for CommonJS output, `import { __helper } from "tslib"` for ES modules.
+ */
+export declare function createExternalHelpersImportDeclarationIfNeeded(context: EmitContext, file: SourceFile, options: CompilerOptions, fileModuleKind: ModuleKind): Node | undefined;
+/** An ES module, or a CommonJS module emitted to a CommonJS-family module kind. */
+export declare function isEffectiveExternalModule(file: SourceFile, options: CompilerOptions): boolean;

package/dist/api/compiler/transformers/external-module-info.js

@@ -0,0 +1,351 @@
+// What a module imports and exports, collected for module transforms.
+import { BindingPattern, BindingElement, ClassDeclaration, ExportAssignment, ExportDeclaration, ExportSpecifier, ExternalModuleReference, FunctionDeclaration, Identifier, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, NamedExports, NamedImports, NamespaceExport, NamespaceImport, NotEmittedStatement, StringLiteral, VariableDeclaration, VariableStatement, getImportClause, } from '../ast.js';
+import { ModuleKind, getEmitModuleKind } from '../options.js';
+import { isFileLevelUniqueName } from '../printer/name-generator.js';
+import { hasSyntacticModifier, isExternalModule } from './utilities.js';
+export class ExternalModuleInfo {
+    /** Imports and re-exports of other modules. */
+    externalImports;
+    /** Export specifiers by local name, excluding re-exports. */
+    exportSpecifiers;
+    /** The export names of each local declaration. */
+    exportedBindings;
+    /** Every exported name, except those of exported function declarations. */
+    exportedNames;
+    /** Exported function declarations, in order. */
+    exportedFunctions;
+    exportEquals;
+    hasExportStarsToExportValues;
+    constructor() {
+        this.externalImports = [];
+        this.exportSpecifiers = new Map();
+        this.exportedBindings = new Map();
+        this.exportedNames = [];
+        this.exportedFunctions = [];
+        this.exportEquals = undefined;
+        this.hasExportStarsToExportValues = false;
+    }
+    getExportedBindings(declaration) {
+        return this.exportedBindings.get(declaration);
+    }
+}
+export function collectExternalModuleInfo(file, context, resolver) {
+    return new ExternalModuleInfoCollector(context, resolver).collect(file);
+}
+class ExternalModuleInfoCollector {
+    context;
+    resolver;
+    output;
+    uniqueExports;
+    exportedFunctionSet;
+    hasExportDefault;
+    constructor(context, resolver) {
+        this.context = context;
+        this.resolver = resolver;
+        this.output = new ExternalModuleInfo();
+        this.uniqueExports = new Set();
+        this.exportedFunctionSet = new Set();
+        this.hasExportDefault = false;
+    }
+    collect(file) {
+        const output = this.output;
+        const statements = file.statements.nodes;
+        for (let i = 0; i < statements.length; i++) {
+            const node = statements[i];
+            if (node instanceof NotEmittedStatement) {
+                // `declare export = x` is elided but still collected.
+                const original = this.context.mostOriginal(node);
+                if (original instanceof ExportAssignment && original.isExportEquals && output.exportEquals === undefined)
+                    output.exportEquals = original;
+                continue;
+            }
+            if (node instanceof ImportDeclaration)
+                output.externalImports.push(node);
+            else if (node instanceof ImportEqualsDeclaration) {
+                if (node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */)
+                    output.externalImports.push(node);
+            }
+            else if (node instanceof ExportDeclaration)
+                this.collectExportDeclaration(node);
+            else if (node instanceof ExportAssignment) {
+                if (node.isExportEquals && output.exportEquals === undefined)
+                    output.exportEquals = node;
+            }
+            else if (node instanceof VariableStatement) {
+                if (hasSyntacticModifier(node, 32 /* ModifierFlags.Export */)) {
+                    const declarations = node.declarationList.declarations.nodes;
+                    for (let j = 0; j < declarations.length; j++)
+                        this.collectExportedVariableInfo(declarations[j]);
+                }
+            }
+            else if (node instanceof FunctionDeclaration) {
+                if (hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
+                    this.addExportedFunctionDeclaration(node, undefined, hasSyntacticModifier(node, 2048 /* ModifierFlags.Default */));
+            }
+            else if (node instanceof ClassDeclaration) {
+                if (hasSyntacticModifier(node, 32 /* ModifierFlags.Export */))
+                    this.collectExportedClass(node);
+            }
+        }
+        return output;
+    }
+    collectExportDeclaration(node) {
+        const output = this.output;
+        if (node.moduleSpecifier === undefined)
+            return this.addExportedNamesForExportDeclaration(node);
+        output.externalImports.push(node);
+        const clause = node.exportClause;
+        if (clause === undefined)
+            output.hasExportStarsToExportValues = true;
+        else if (clause instanceof NamedExports)
+            this.addExportedNamesForExportDeclaration(node);
+        else if (clause instanceof NamespaceExport) {
+            const name = clause.name;
+            if (this.addUniqueExport(moduleExportNameText(name))) {
+                this.addExportedBinding(node, name);
+                output.exportedNames.push(name);
+            }
+        }
+        return true;
+    }
+    collectExportedClass(node) {
+        if (hasSyntacticModifier(node, 2048 /* ModifierFlags.Default */)) {
+            if (!this.hasExportDefault) {
+                const name = node.name !== undefined ? node.name : this.context.factory.createGeneratedNameForNode(node, 0, '', '');
+                this.addExportedBinding(node, name);
+                this.hasExportDefault = true;
+            }
+        }
+        else if (node.name !== undefined && this.addUniqueExport(node.name.text)) {
+            this.addExportedBinding(node, node.name);
+            this.output.exportedNames.push(node.name);
+        }
+        return true;
+    }
+    addUniqueExport(name) {
+        if (this.uniqueExports.has(name))
+            return false;
+        this.uniqueExports.add(name);
+        return true;
+    }
+    addExportedBinding(declaration, name) {
+        const key = this.context.mostOriginal(declaration);
+        const names = this.output.exportedBindings.get(key);
+        if (names === undefined)
+            this.output.exportedBindings.set(key, [name]);
+        else
+            names.push(name);
+        return true;
+    }
+    addExportedNamesForExportDeclaration(node) {
+        const clause = node.exportClause;
+        if (!(clause instanceof NamedExports))
+            return false;
+        const specifiers = clause.elements.nodes;
+        for (let i = 0; i < specifiers.length; i++) {
+            const specifier = specifiers[i];
+            if (!(specifier instanceof ExportSpecifier))
+                continue;
+            const exportName = moduleExportNameText(specifier.name);
+            if (!this.addUniqueExport(exportName))
+                continue;
+            const local = specifier.propertyName !== undefined ? specifier.propertyName : specifier.name;
+            if (local instanceof Identifier) {
+                if (node.moduleSpecifier === undefined) {
+                    const existing = this.output.exportSpecifiers.get(local.text);
+                    if (existing === undefined)
+                        this.output.exportSpecifiers.set(local.text, [specifier]);
+                    else
+                        existing.push(specifier);
+                }
+                const original = this.context.mostOriginal(local);
+                let declaration = undefined;
+                if (original instanceof Identifier) {
+                    declaration = this.resolver.getReferencedImportDeclaration(original);
+                    if (declaration === undefined)
+                        declaration = this.resolver.getReferencedValueDeclaration(original);
+                }
+                if (declaration instanceof FunctionDeclaration) {
+                    this.uniqueExports.delete(exportName);
+                    this.addExportedFunctionDeclaration(declaration, specifier.name, exportName === 'default');
+                    continue;
+                }
+                if (declaration !== undefined)
+                    this.addExportedBinding(declaration, specifier.name);
+            }
+            this.output.exportedNames.push(specifier.name);
+        }
+        return true;
+    }
+    addExportedFunctionDeclaration(node, name, isDefault) {
+        const key = this.context.mostOriginal(node);
+        if (!this.exportedFunctionSet.has(key)) {
+            this.exportedFunctionSet.add(key);
+            if (key instanceof FunctionDeclaration)
+                this.output.exportedFunctions.push(key);
+        }
+        if (isDefault) {
+            if (!this.hasExportDefault) {
+                this.addExportedBinding(node, name !== undefined ? name : this.context.factory.createGeneratedNameForNode(node, 0, '', ''));
+                this.hasExportDefault = true;
+            }
+            return true;
+        }
+        const exportName = name !== undefined ? name : node.name;
+        if (exportName !== undefined && this.addUniqueExport(moduleExportNameText(exportName)))
+            this.addExportedBinding(node, exportName);
+        return true;
+    }
+    collectExportedVariableInfo(declaration) {
+        const name = declaration instanceof VariableDeclaration ? declaration.name : bindingElementName(declaration);
+        if (name instanceof BindingPattern) {
+            const elements = name.elements.nodes;
+            for (let i = 0; i < elements.length; i++)
+                if (bindingElementName(elements[i]) !== undefined)
+                    this.collectExportedVariableInfo(elements[i]);
+            return true;
+        }
+        if (!(name instanceof Identifier) || this.context.hasAutoGenerateInfo(name))
+            return false;
+        if (this.addUniqueExport(name.text)) {
+            this.output.exportedNames.push(name);
+            if ((this.context.getEmitFlags(name) & 4096 /* EmitFlags.LocalName */) !== 0)
+                this.addExportedBinding(declaration, name);
+        }
+        return true;
+    }
+}
+function bindingElementName(node) {
+    return node instanceof BindingElement ? node.name : undefined;
+}
+export function moduleExportNameText(name) {
+    if (name instanceof Identifier)
+        return name.text;
+    if (name instanceof StringLiteral)
+        return name.text;
+    return '';
+}
+/** `import * as ns` (or `export * as ns`), else undefined. */
+export function getNamespaceDeclarationNode(node) {
+    if (node instanceof ImportDeclaration) {
+        const clause = node.importClause;
+        return clause !== undefined && clause.namedBindings instanceof NamespaceImport ? clause.namedBindings : undefined;
+    }
+    if (node instanceof ImportEqualsDeclaration)
+        return node;
+    if (node instanceof ExportDeclaration)
+        return node.exportClause instanceof NamespaceExport ? node.exportClause : undefined;
+    return undefined;
+}
+export function isDefaultImport(node) {
+    const clause = getImportClause(node);
+    return clause instanceof ImportClause && clause.name !== undefined;
+}
+function isNamedDefaultReference(specifier) {
+    if (specifier instanceof ImportSpecifier)
+        return (moduleExportNameText(specifier.propertyName !== undefined ? specifier.propertyName : specifier.name) === 'default');
+    if (specifier instanceof ExportSpecifier)
+        return (moduleExportNameText(specifier.propertyName !== undefined ? specifier.propertyName : specifier.name) === 'default');
+    return false;
+}
+export function containsDefaultReference(node) {
+    let elements = [];
+    if (node instanceof NamedImports)
+        elements = node.elements.nodes;
+    else if (node instanceof NamedExports)
+        elements = node.elements.nodes;
+    for (let i = 0; i < elements.length; i++)
+        if (isNamedDefaultReference(elements[i]))
+            return true;
+    return false;
+}
+export function getImportNeedsImportStarHelper(node) {
+    if (getNamespaceDeclarationNode(node) !== undefined)
+        return true;
+    const clause = node.importClause;
+    if (clause === undefined || !(clause.namedBindings instanceof NamedImports))
+        return false;
+    const elements = clause.namedBindings.elements.nodes;
+    let defaultReferences = 0;
+    for (let i = 0; i < elements.length; i++)
+        if (isNamedDefaultReference(elements[i]))
+            defaultReferences++;
+    // Default references mixed with other names, or other names with a default import.
+    return ((defaultReferences > 0 && defaultReferences !== elements.length) ||
+        (elements.length - defaultReferences !== 0 && isDefaultImport(node)));
+}
+export function getImportNeedsImportDefaultHelper(node) {
+    if (getImportNeedsImportStarHelper(node))
+        return false;
+    if (isDefaultImport(node))
+        return true;
+    const clause = node.importClause;
+    return clause !== undefined && containsDefaultReference(clause.namedBindings);
+}
+const externalHelpersModuleNameText = 'tslib';
+/**
+ * With `importHelpers`, the import of the helpers a module uses: `import tslib = require("tslib")`
+ * for CommonJS output, `import { __helper } from "tslib"` for ES modules.
+ */
+export function createExternalHelpersImportDeclarationIfNeeded(context, file, options, fileModuleKind) {
+    if (options.importHelpers !== true || !isEffectiveExternalModule(file, options))
+        return undefined;
+    const factory = context.factory;
+    const helpers = getImportedHelpers(context, file);
+    const moduleKind = getEmitModuleKind(options);
+    if (fileModuleKind === ModuleKind.CommonJS ||
+        (fileModuleKind === ModuleKind.None && moduleKind === ModuleKind.CommonJS)) {
+        let moduleName = context.getExternalHelpersModuleName(file);
+        if (moduleName === undefined) {
+            if (helpers.length === 0)
+                return undefined;
+            moduleName = factory.createUniqueName(externalHelpersModuleNameText, 0 /* GeneratedIdentifierFlags.None */);
+            context.setExternalHelpersModuleName(file, moduleName);
+        }
+        const declaration = factory.created(new ImportEqualsDeclaration(undefined, false, moduleName, factory.created(new ExternalModuleReference(factory.createStringLiteral(externalHelpersModuleNameText, 0 /* TokenFlags.None */)))));
+        context.addEmitFlags(declaration, 65536 /* EmitFlags.CustomPrologue */);
+        return declaration;
+    }
+    const names = [];
+    for (let i = 0; i < helpers.length; i++) {
+        const importName = helpers[i].importName;
+        if (importName.length > 0 && names.indexOf(importName) < 0)
+            names.push(importName);
+    }
+    if (names.length === 0)
+        return undefined;
+    names.sort(compareStringsCaseSensitive);
+    const specifiers = [];
+    for (let i = 0; i < names.length; i++) {
+        const name = names[i];
+        // Aliased when the name is used in the file.
+        specifiers.push(isFileLevelUniqueName(file, name)
+            ? factory.created(new ImportSpecifier(false, undefined, factory.createIdentifier(name)))
+            : factory.created(new ImportSpecifier(false, factory.createIdentifier(name), factory.createUnscopedHelperName(name))));
+    }
+    context.addEmitFlags(context.mostOriginal(file), 262144 /* EmitFlags.ExternalHelpers */);
+    const declaration = factory.created(new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, undefined, factory.created(new ImportClause(undefined, undefined, factory.created(new NamedImports(factory.createNodeList(specifiers))))), factory.createStringLiteral(externalHelpersModuleNameText, 0 /* TokenFlags.None */), undefined));
+    context.addEmitFlags(declaration, 65536 /* EmitFlags.CustomPrologue */);
+    return declaration;
+}
+function getImportedHelpers(context, file) {
+    const all = context.getEmitHelpers(file);
+    const helpers = [];
+    if (all === undefined)
+        return helpers;
+    for (let i = 0; i < all.length; i++)
+        if (!all[i].scoped)
+            helpers.push(all[i]);
+    return helpers;
+}
+function compareStringsCaseSensitive(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/** An ES module, or a CommonJS module emitted to a CommonJS-family module kind. */
+export function isEffectiveExternalModule(file, options) {
+    if (isExternalModule(file))
+        return true;
+    const kind = getEmitModuleKind(options);
+    return ((kind === ModuleKind.CommonJS || (kind >= ModuleKind.Node16 && kind <= ModuleKind.NodeNext)) &&
+        file.commonJSModuleIndicator !== undefined);
+}

package/dist/api/compiler/transformers/for-await.d.ts

@@ -0,0 +1,43 @@
+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 AsyncIteration extends Transformer {
+    private readonly facts;
+    private readonly superAccess;
+    private readonly fallbackVisitor;
+    private enclosingFunctionFlags;
+    private hierarchyFacts;
+    constructor(context: EmitContext, facts: SyntaxFacts);
+    fallback(node: Node): Node | undefined;
+    private inAsyncGenerator;
+    visit(node: Node): Node | undefined;
+    private visitWithFacts;
+    private visitScope;
+    private visitSourceFile;
+    /** `await x` in an async generator as `yield __await(x)`. */
+    private visitAwaitExpression;
+    /** `yield x` as `yield yield __await(x)`; `yield* x` as `yield __await(yield* __asyncDelegator(__asyncValues(x)))`. */
+    private visitYieldExpression;
+    private visitReturnStatement;
+    private visitLabeledStatement;
+    private restoreEnclosingLabel;
+    private visitForOfStatement;
+    private createDownlevelAwait;
+    /** The loop body: assigns the iterated value, clears `nonUserCode`, binds the loop variable. */
+    private convertForOfStatementHead;
+    private createForOfBindingStatement;
+    private transformForAwaitOfStatement;
+    private visitConstructor;
+    private visitGetAccessor;
+    private visitSetAccessor;
+    /** Modifiers without `async` for generators, whose `async` moves to `__asyncGenerator`. */
+    private generatorModifiers;
+    private visitMethodDeclaration;
+    private visitFunctionDeclaration;
+    private visitFunctionExpression;
+    private visitArrowFunction;
+    /** The visited parameters if simple, else placeholders up to the first initializer or rest, keeping `length`. */
+    private transformAsyncGeneratorParameterList;
+    private transformAsyncGeneratorBody;
+}