tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,46 @@
+import { BinaryExpression, Block, ExportAssignment, ExportDeclaration, HeritageClause, Identifier, type ModifierList, type Node, NodeList, PropertyDeclaration, ComputedPropertyName } from '../ast.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import type { NodeFactory } from '../printer/factory.js';
+import { SyntaxKind } from '../syntax-kind.js';
+/** `super.x` or `super[x]` */
+export declare function isSuperProperty(node: Node): boolean;
+export declare function isCompoundAssignment(kind: SyntaxKind): boolean;
+/** `+` for `+=`, and so on. */
+export declare function getNonAssignmentOperatorForCompoundAssignment(kind: SyntaxKind): SyntaxKind;
+/** The number of leading prologue directives. */
+export declare function countPrologueDirectives(statements: Node[]): number;
+/** The `super()` call of an expression statement, if it is one. */
+export declare function getSuperCallFromStatement(statement: Node): Node | undefined;
+/** Indices leading to the statement with the `super()` call, descending into `try` blocks; empty if none. */
+export declare function findSuperStatementIndexPath(statements: Node[], start: number): number[];
+/** The `extends` or `implements` clause of a class. */
+export declare function getHeritageClause(clauses: NodeList | undefined, kind: SyntaxKind): HeritageClause | undefined;
+/** The single `_classThis = this` assignment block recorded with `setClassThis`. */
+export declare function isClassThisAssignmentBlock(context: EmitContext, node: Node): boolean;
+/** Whether a class has a `_classThis = this` block. */
+export declare function classHasClassThisAssignment(context: EmitContext, members: NodeList): boolean;
+/** The members of a class declaration or expression. */
+export declare function getClassMembers(node: Node): NodeList;
+/** The heritage clauses of a class declaration or expression. */
+export declare function getClassHeritageClauses(node: Node): NodeList | undefined;
+/** The name of a class declaration or expression. */
+export declare function getClassName(node: Node): Identifier | undefined;
+/** A class declaration or expression with other members. */
+export declare function updateClassMembers(factory: NodeFactory, node: Node, members: NodeList): Node;
+/** Prepends `static { _classThis = this; }` to a class unless it has one. */
+export declare function injectClassThisAssignmentIfMissing(context: EmitContext, node: Node, classThis: Identifier): Node;
+/** The private backing field `#x_accessor_storage` of an `accessor x` field. */
+export declare function createAccessorPropertyBackingField(factory: NodeFactory, node: PropertyDeclaration, modifiers: ModifierList | undefined, initializer: Node | undefined): PropertyDeclaration;
+/** The cached `_a = expr` assignment a computed property name was transformed into, if any. */
+export declare function findComputedPropertyNameCacheAssignment(name: ComputedPropertyName): BinaryExpression | undefined;
+/**
+ * `(_a = expression, ++_a)` for `++x`, or `(_a = expression, _a++, _a)` for `x++`, assigning the
+ * operation to `resultVariable` when given.
+ */
+export declare function expandPreOrPostfixIncrementOrDecrementExpression(context: EmitContext, node: Node, expression: Node, resultVariable: Identifier | undefined): Node;
+/** `export default expression;` */
+export declare function createExportDefault(factory: NodeFactory, expression: Node): ExportAssignment;
+/** `export { name };` */
+export declare function createExternalModuleExport(factory: NodeFactory, name: Identifier): ExportDeclaration;
+/** A block of statements, keeping `block`'s range and original. */
+export declare function updateBlockStatements(context: EmitContext, block: Block, statements: Node[]): Block;

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

@@ -0,0 +1,261 @@
+// Expression and class-element utilities shared by the class transforms: outer expressions,
+// `super` accesses, constructor bodies, `_classThis` blocks and auto-accessor backing fields.
+import { BinaryExpression, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ElementAccessExpression, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, HeritageClause, Identifier, NamedExports, NodeList, ParenthesizedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAccessExpression, TryStatement, CallExpression, } from '../ast.js';
+import { isAssignmentExpression, isClassLike } from '../binder-utilities.js';
+import { isPrologueDirective } from '../printer/utilities.js';
+import { skipOuterExpressions } from './utilities.js';
+/** `super.x` or `super[x]` */
+export function isSuperProperty(node) {
+    if (node instanceof PropertyAccessExpression)
+        return node.expression.kind === 107 /* SyntaxKind.SuperKeyword */;
+    if (node instanceof ElementAccessExpression)
+        return node.expression.kind === 107 /* SyntaxKind.SuperKeyword */;
+    return false;
+}
+export function isCompoundAssignment(kind) {
+    return kind >= 64 /* SyntaxKind.FirstCompoundAssignment */ && kind <= 78 /* SyntaxKind.LastCompoundAssignment */;
+}
+/** `+` for `+=`, and so on. */
+export function getNonAssignmentOperatorForCompoundAssignment(kind) {
+    switch (kind) {
+        case 64 /* SyntaxKind.PlusEqualsToken */:
+            return 39 /* SyntaxKind.PlusToken */;
+        case 65 /* SyntaxKind.MinusEqualsToken */:
+            return 40 /* SyntaxKind.MinusToken */;
+        case 66 /* SyntaxKind.AsteriskEqualsToken */:
+            return 41 /* SyntaxKind.AsteriskToken */;
+        case 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */:
+            return 42 /* SyntaxKind.AsteriskAsteriskToken */;
+        case 68 /* SyntaxKind.SlashEqualsToken */:
+            return 43 /* SyntaxKind.SlashToken */;
+        case 69 /* SyntaxKind.PercentEqualsToken */:
+            return 44 /* SyntaxKind.PercentToken */;
+        case 70 /* SyntaxKind.LessThanLessThanEqualsToken */:
+            return 47 /* SyntaxKind.LessThanLessThanToken */;
+        case 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */:
+            return 48 /* SyntaxKind.GreaterThanGreaterThanToken */;
+        case 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */:
+            return 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */;
+        case 73 /* SyntaxKind.AmpersandEqualsToken */:
+            return 50 /* SyntaxKind.AmpersandToken */;
+        case 74 /* SyntaxKind.BarEqualsToken */:
+            return 51 /* SyntaxKind.BarToken */;
+        case 78 /* SyntaxKind.CaretEqualsToken */:
+            return 52 /* SyntaxKind.CaretToken */;
+        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 kind;
+}
+/** The number of leading prologue directives. */
+export function countPrologueDirectives(statements) {
+    for (let i = 0; i < statements.length; i++)
+        if (!isPrologueDirective(statements[i]))
+            return i;
+    return statements.length;
+}
+/** The `super()` call of an expression statement, if it is one. */
+export function getSuperCallFromStatement(statement) {
+    if (!(statement instanceof ExpressionStatement))
+        return undefined;
+    let expression = statement.expression;
+    while (expression instanceof ParenthesizedExpression)
+        expression = expression.expression;
+    return expression instanceof CallExpression && expression.expression.kind === 107 /* SyntaxKind.SuperKeyword */
+        ? expression
+        : undefined;
+}
+/** Indices leading to the statement with the `super()` call, descending into `try` blocks; empty if none. */
+export function findSuperStatementIndexPath(statements, start) {
+    const path = [];
+    if (!findSuperStatementIndexPathWorker(statements, start, path))
+        return [];
+    return path.reverse();
+}
+function findSuperStatementIndexPathWorker(statements, start, path) {
+    for (let i = start; i < statements.length; i++) {
+        const statement = statements[i];
+        if (getSuperCallFromStatement(statement) !== undefined) {
+            path.push(i);
+            return true;
+        }
+        if (statement instanceof TryStatement &&
+            findSuperStatementIndexPathWorker(statement.tryBlock.statements.nodes, 0, path)) {
+            path.push(i);
+            return true;
+        }
+    }
+    return false;
+}
+/** The `extends` or `implements` clause of a class. */
+export function getHeritageClause(clauses, kind) {
+    if (clauses === undefined)
+        return undefined;
+    for (let i = 0; i < clauses.nodes.length; i++) {
+        const clause = clauses.nodes[i];
+        if (clause instanceof HeritageClause && clause.token === kind)
+            return clause;
+    }
+    return undefined;
+}
+/** The single `_classThis = this` assignment block recorded with `setClassThis`. */
+export function isClassThisAssignmentBlock(context, node) {
+    if (!(node instanceof ClassStaticBlockDeclaration))
+        return false;
+    const statements = node.body.statements.nodes;
+    if (statements.length !== 1)
+        return false;
+    const statement = statements[0];
+    if (!(statement instanceof ExpressionStatement))
+        return false;
+    const expression = statement.expression;
+    if (!(expression instanceof BinaryExpression) || !isAssignmentExpression(expression, true))
+        return false;
+    return (expression.left instanceof Identifier &&
+        context.getClassThis(node) === expression.left &&
+        expression.right.kind === 109 /* SyntaxKind.ThisKeyword */);
+}
+/** Whether a class has a `_classThis = this` block. */
+export function classHasClassThisAssignment(context, members) {
+    for (let i = 0; i < members.nodes.length; i++)
+        if (isClassThisAssignmentBlock(context, members.nodes[i]))
+            return true;
+    return false;
+}
+/** The members of a class declaration or expression. */
+export function getClassMembers(node) {
+    if (node instanceof ClassDeclaration)
+        return node.members;
+    if (node instanceof ClassExpression)
+        return node.members;
+    throw new Error('Expected a class');
+}
+/** The heritage clauses of a class declaration or expression. */
+export function getClassHeritageClauses(node) {
+    if (node instanceof ClassDeclaration)
+        return node.heritageClauses;
+    if (node instanceof ClassExpression)
+        return node.heritageClauses;
+    return undefined;
+}
+/** The name of a class declaration or expression. */
+export function getClassName(node) {
+    if (node instanceof ClassDeclaration)
+        return node.name;
+    if (node instanceof ClassExpression)
+        return node.name;
+    return undefined;
+}
+/** A class declaration or expression with other members. */
+export function updateClassMembers(factory, node, members) {
+    if (node instanceof ClassDeclaration) {
+        const declaration = node;
+        return factory.updateClassDeclaration(declaration, declaration.modifiers, declaration.name, declaration.typeParameters, declaration.heritageClauses, members);
+    }
+    if (node instanceof ClassExpression) {
+        const expression = node;
+        return factory.updateClassExpression(expression, expression.modifiers, expression.name, expression.typeParameters, expression.heritageClauses, members);
+    }
+    return node;
+}
+/** Prepends `static { _classThis = this; }` to a class unless it has one. */
+export function injectClassThisAssignmentIfMissing(context, node, classThis) {
+    if (!isClassLike(node))
+        return node;
+    const existing = getClassMembers(node);
+    if (classHasClassThisAssignment(context, existing))
+        return node;
+    const factory = context.factory;
+    const statement = factory.createExpressionStatement(factory.createAssignment(classThis, factory.createKeywordExpression(109 /* SyntaxKind.ThisKeyword */)));
+    const staticBlock = factory.created(new ClassStaticBlockDeclaration(undefined, factory.createBlock([statement], false)));
+    context.setClassThis(staticBlock, classThis);
+    const name = getClassName(node);
+    if (name !== undefined)
+        context.setSourceMapRange(statement, name.pos, name.end);
+    const members = new NodeList(existing.pos, existing.end, [staticBlock].concat(existing.nodes));
+    const updated = updateClassMembers(factory, node, members);
+    context.setClassThis(updated, classThis);
+    return updated;
+}
+/** The private backing field `#x_accessor_storage` of an `accessor x` field. */
+export function createAccessorPropertyBackingField(factory, node, modifiers, initializer) {
+    return factory.updatePropertyDeclaration(node, modifiers, factory.createGeneratedPrivateNameForNode(node.name, '', '_accessor_storage'), undefined, undefined, initializer);
+}
+/** The cached `_a = expr` assignment a computed property name was transformed into, if any. */
+export function findComputedPropertyNameCacheAssignment(name) {
+    let node = name.expression;
+    for (;;) {
+        node = skipOuterExpressions(node, 0 /* OuterExpressionKinds.None */);
+        if (node instanceof BinaryExpression && node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) {
+            node = node.right;
+            continue;
+        }
+        if (node instanceof BinaryExpression && isAssignmentExpression(node, true) && node.left instanceof Identifier)
+            return node;
+        return undefined;
+    }
+}
+/**
+ * `(_a = expression, ++_a)` for `++x`, or `(_a = expression, _a++, _a)` for `x++`, assigning the
+ * operation to `resultVariable` when given.
+ */
+export function expandPreOrPostfixIncrementOrDecrementExpression(context, node, expression, resultVariable) {
+    const factory = context.factory;
+    const prefix = node instanceof PrefixUnaryExpression;
+    let operator = 0 /* SyntaxKind.Unknown */;
+    let operand = node;
+    if (node instanceof PrefixUnaryExpression) {
+        operator = node.operator;
+        operand = node.operand;
+    }
+    else if (node instanceof PostfixUnaryExpression) {
+        operator = node.operator;
+        operand = node.operand;
+    }
+    const temp = factory.createTempVariable(0);
+    context.addVariableDeclaration(temp);
+    expression = factory.createAssignment(temp, expression);
+    expression.pos = operand.pos;
+    expression.end = operand.end;
+    let operation = prefix
+        ? factory.createPrefixUnaryExpression(operator, temp)
+        : factory.created(new PostfixUnaryExpression(temp, operator));
+    operation.pos = node.pos;
+    operation.end = node.end;
+    if (resultVariable !== undefined) {
+        operation = factory.createAssignment(resultVariable, operation);
+        operation.pos = node.pos;
+        operation.end = node.end;
+    }
+    expression = factory.createCommaExpression(expression, operation);
+    expression.pos = node.pos;
+    expression.end = node.end;
+    if (!prefix) {
+        expression = factory.createCommaExpression(expression, temp);
+        expression.pos = node.pos;
+        expression.end = node.end;
+    }
+    return expression;
+}
+/** `export default expression;` */
+export function createExportDefault(factory, expression) {
+    return factory.created(new ExportAssignment(undefined, false, undefined, expression));
+}
+/** `export { name };` */
+export function createExternalModuleExport(factory, name) {
+    const specifier = factory.created(new ExportSpecifier(false, undefined, name));
+    const exports = factory.created(new NamedExports(factory.createNodeList([specifier])));
+    return factory.created(new ExportDeclaration(undefined, false, exports, undefined, undefined));
+}
+/** A block of statements, keeping `block`'s range and original. */
+export function updateBlockStatements(context, block, statements) {
+    const updated = context.factory.createBlock(statements, block.multiLine);
+    context.setOriginal(updated, block);
+    updated.pos = block.pos;
+    updated.end = block.end;
+    return updated;
+}

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

@@ -0,0 +1,103 @@
+import { Identifier, type Node } from '../ast.js';
+import { type CompilerOptions, ModuleKind, ScriptTarget } from '../options.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import type { EmitResolver } from './emit-resolver.js';
+import type { ModuleFormatHost } from './module.js';
+import { Transformer } from './transformer.js';
+declare const enum VisitMode {
+    /** Statements at the top level of the module. */
+    TopLevel = 0,
+    /** Statements nested in top-level statements, whose `var`s are module scoped. */
+    TopLevelNested = 1,
+    /** Expressions whose value is unused. */
+    DiscardedValue = 2
+}
+export declare class CommonJSModuleTransformer extends Transformer {
+    readonly options: CompilerOptions;
+    readonly resolver: EmitResolver;
+    readonly formats: ModuleFormatHost;
+    readonly moduleKind: ModuleKind;
+    readonly languageVersion: ScriptTarget;
+    private readonly topLevel;
+    private readonly topLevelNested;
+    private readonly discarded;
+    private readonly exportAssignments;
+    private currentSourceFile;
+    private info;
+    private parentNode;
+    private currentNode;
+    constructor(context: EmitContext, options: CompilerOptions, resolver: EmitResolver, formats: ModuleFormatHost);
+    private moduleInfo;
+    visit(node: Node): Node | undefined;
+    visitInMode(mode: VisitMode, node: Node): Node | undefined;
+    private pushNode;
+    private popNode;
+    private visitTopLevel;
+    private visitTopLevelNestedNoStack;
+    /** Visits a node other than a top-level statement; `discarded` if its value is unused. */
+    private visitNoStack;
+    private visitSourceFile;
+    private shouldEmitUnderscoreUnderscoreESModule;
+    /** `Object.defineProperty(exports, "__esModule", { value: true });` */
+    private createUnderscoreUnderscoreESModule;
+    private transformCommonJSModule;
+    private customPrologueEnd;
+    /** `exports.x` or `exports["x"]` for an export name. */
+    private createExportsReference;
+    private cloneName;
+    /** `module.exports = x;` for `export = x`. */
+    private appendExportEqualsIfNeeded;
+    private appendExportsOfImportDeclaration;
+    private appendExportsOfVariableDeclarationList;
+    private appendExportsOfBindingElement;
+    private appendExportsOfClassOrFunctionDeclaration;
+    private appendExportsOfDeclaration;
+    private appendExportStatement;
+    private createExportStatement;
+    /** `exports.x = value`, or a getter on `exports` for a live binding. */
+    private createExportExpression;
+    /** `require("mod")` */
+    private createRequireCall;
+    private getHelperExpressionForImport;
+    private visitTopLevelImportDeclaration;
+    private visitTopLevelImportEqualsDeclaration;
+    private visitTopLevelExportDeclaration;
+    private visitTopLevelExportAssignment;
+    private visitTopLevelFunctionDeclaration;
+    private visitTopLevelClassDeclaration;
+    private visitTopLevelVariableStatement;
+    private transformInitializedVariable;
+    private visitTopLevelNestedForStatement;
+    private visitTopLevelNestedForInOrOfStatement;
+    private visitBinaryExpression;
+    /** Assigning an exported name also assigns each of its exports. */
+    private visitAssignmentExpression;
+    /** Not generated (except file-level reserved names) and not a local name. */
+    private isSubstitutableName;
+    private visitDestructuringAssignment;
+    /** Whether a destructuring target assigns an exported name that native destructuring can't update. */
+    private destructuringNeedsFlattening;
+    /** The assignment of a flattened destructuring target, assigning its exports too. */
+    createAllExportExpressions(name: Identifier, value: Node, pos: number, end: number): Node;
+    /** `exports.x = value` for a directly exported `x`. */
+    private createDirectExportAssignment;
+    /** Whether `name` refers to a declaration exported by the module itself, like `export let x`. */
+    private isDirectExport;
+    private visitPrefixUnaryExpression;
+    private visitPostfixUnaryExpression;
+    /** `(0, mod_1.f)()` for a call of an import; `import()` becomes a `require` call. */
+    private visitCallExpression;
+    private shouldTransformImportCall;
+    private visitImportCallExpression;
+    /** `Promise.resolve().then(() => __importStar(require(x)))` */
+    private createImportCallExpressionCommonJS;
+    private rewriteImportOrRequireCall;
+    private visitTaggedTemplateExpression;
+    private visitShorthandPropertyAssignment;
+    /** `exports.x` for an exported name, `mod_1.x` or `mod_1.default` for an import. */
+    private visitExpressionIdentifier;
+    /** The export names of what `name` refers to. */
+    private getExports;
+    private isFileLevelReservedGeneratedIdentifier;
+}
+export {};