tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/printer/helpers.js

@@ -0,0 +1,164 @@
+// Runtime helpers emitted at the top of a file, or imported from tslib with `importHelpers`.
+/** A runtime helper such as `__decorate`, emitted once at the top of a file or scope. */
+export class EmitHelper {
+    name;
+    /** Emitted in the scope that uses it rather than at the top of the file. */
+    scoped;
+    text;
+    /** Lower values are emitted first; helpers without a priority come last. */
+    priority;
+    dependencies;
+    importName;
+    /** For helpers that declare a file-level unique name: the base name, written in place of each `{name}` in `text`. */
+    uniqueName;
+    constructor(name, scoped, text, priority, dependencies, importName, uniqueName) {
+        this.name = name;
+        this.scoped = scoped;
+        this.text = text;
+        this.priority = priority;
+        this.dependencies = dependencies;
+        this.importName = importName;
+        this.uniqueName = uniqueName;
+    }
+}
+export const noPriority = -1;
+export function compareEmitHelpers(x, y) {
+    if (x === y || x.priority === y.priority)
+        return 0;
+    if (x.priority === noPriority)
+        return 1;
+    if (y.priority === noPriority)
+        return -1;
+    return x.priority - y.priority;
+}
+const createBindingHelper = new EmitHelper('typescript:commonjscreatebinding', false, `var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));`, 1, [], '__createBinding', '');
+const setModuleDefaultHelper = new EmitHelper('typescript:commonjscreatevalue', false, `var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});`, 1, [], '__setModuleDefault', '');
+export const importStarHelper = new EmitHelper('typescript:commonjsimportstar', false, `var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();`, 2, [createBindingHelper, setModuleDefaultHelper], '__importStar', '');
+export const importDefaultHelper = new EmitHelper('typescript:commonjsimportdefault', false, `var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};`, noPriority, [], '__importDefault', '');
+export const exportStarHelper = new EmitHelper('typescript:export-star', false, `var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};`, 2, [createBindingHelper], '__exportStar', '');
+export const rewriteRelativeImportExtensionsHelper = new EmitHelper('typescript:rewriteRelativeImportExtensions', false, `var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\\.\\.?\\//.test(path)) {
+        return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};`, noPriority, [], '__rewriteRelativeImportExtension', '');
+export const restHelper = new EmitHelper('typescript:rest', false, `var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};`, noPriority, [], '__rest', '');
+export const classPrivateFieldGetHelper = new EmitHelper('typescript:classPrivateFieldGet', false, `var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};`, noPriority, [], '__classPrivateFieldGet', '');
+export const classPrivateFieldSetHelper = new EmitHelper('typescript:classPrivateFieldSet', false, `var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};`, noPriority, [], '__classPrivateFieldSet', '');
+export const classPrivateFieldInHelper = new EmitHelper('typescript:classPrivateFieldIn', false, `var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(state, receiver) {
+    if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
+    return typeof state === "function" ? receiver === state : state.has(receiver);
+};`, noPriority, [], '__classPrivateFieldIn', '');
+export const makeTemplateObjectHelper = new EmitHelper('typescript:makeTemplateObject', false, `var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};`, 0, [], '__makeTemplateObject', '');
+// ES2018 helpers
+// ESNext helpers
+export const addDisposableResourceHelper = new EmitHelper('typescript:addDisposableResource', false, `var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};`, noPriority, [], '__addDisposableResource', '');
+export const disposeResourcesHelper = new EmitHelper('typescript:disposeResources', false, `var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});`, noPriority, [], '__disposeResources', '');

package/dist/api/compiler/printer/name-generator.d.ts

@@ -0,0 +1,41 @@
+import { type Node, SourceFile } from '../ast.js';
+import type { EmitContext } from './emit-context.js';
+/** Where to look for name conflicts outside generated names. */
+export declare abstract class NameGeneratorHost {
+    /** The text of an identifier, private identifier or literal as printed. */
+    abstract getTextOfNode(node: Node): string;
+    /** Whether no identifier in the file (or global scope) has this name. */
+    abstract isFileLevelUniqueName(name: string): boolean;
+}
+export declare class NameGenerator {
+    readonly context: EmitContext;
+    readonly host: NameGeneratorHost;
+    private readonly nodeNames;
+    private readonly privateNodeNames;
+    private readonly autoGeneratedNames;
+    private scope;
+    private privateScope;
+    private readonly generatedNames;
+    constructor(context: EmitContext, host: NameGeneratorHost);
+    pushScope(reuseTempVariableScope: boolean): boolean;
+    popScope(reuseTempVariableScope: boolean): boolean;
+    private ensureScope;
+    private getTempFlags;
+    private setTempFlags;
+    private reserveName;
+    /** The text of a name: generated if it has auto-generate info, else its own text. */
+    generateName(name: Node): string;
+    private generateNameForNodeCached;
+    private generateNameForNode;
+    private makeName;
+    private makeTempVariableName;
+    private makeUniqueName;
+    makeFileLevelOptimisticUniqueName(name: string): string;
+    private checkUniqueName;
+    private isUniqueName;
+    private isReservedName;
+}
+/** Forgets the files of earlier emits. */
+export declare function forgetIdentifierSets(): void;
+/** Whether no identifier in `file` is named `name`. */
+export declare function isFileLevelUniqueName(file: SourceFile, name: string): boolean;

package/dist/api/compiler/printer/name-generator.js

@@ -0,0 +1,283 @@
+// Chooses the text of generated identifiers (`_a`, `_i`, `name_1`, …) while printing.
+import { ClassExpression, ExportAssignment, PrivateIdentifier, StringLiteral, getLocals, getNextContainer, getText, isLocalsContainer, } from '../ast.js';
+import { getName } from '../ast.js';
+import { getExternalModuleName } from '../ast-utilities.js';
+import { ensureLeadingHash, formatGeneratedName, makeIdentifierFromModuleName, removeLeadingHash, } from './utilities.js';
+class NameScope {
+    next;
+    tempFlags;
+    formattedNameTempFlags;
+    reservedNames;
+    constructor(next) {
+        this.next = next;
+        this.tempFlags = 0 /* TempFlags.Auto */;
+        this.formattedNameTempFlags = undefined;
+        this.reservedNames = undefined;
+    }
+}
+/** Where to look for name conflicts outside generated names. */
+export class NameGeneratorHost {
+}
+/** Whether no value declared in `container` or its nested containers has `name`, from the binder's locals. */
+function isUniqueLocalName(name, container) {
+    for (let node = container; node !== undefined && isLocalsContainer(node); node = getNextContainer(node)) {
+        if (!isDescendantOf(node, container))
+            break;
+        const locals = getLocals(node);
+        const local = locals === undefined ? undefined : locals.get(name);
+        if (local !== undefined && (local.flags & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */ | 2097152 /* SymbolFlags.Alias */)) !== 0)
+            return false;
+    }
+    return true;
+}
+function isDescendantOf(node, ancestor) {
+    for (let current = node; current !== undefined; current = current.parent)
+        if (current === ancestor)
+            return true;
+    return false;
+}
+export class NameGenerator {
+    context;
+    host;
+    nodeNames;
+    privateNodeNames;
+    autoGeneratedNames;
+    scope;
+    privateScope;
+    generatedNames;
+    constructor(context, host) {
+        this.context = context;
+        this.host = host;
+        this.nodeNames = new Map();
+        this.privateNodeNames = new Map();
+        this.autoGeneratedNames = new Map();
+        this.scope = undefined;
+        this.privateScope = undefined;
+        this.generatedNames = new Set();
+    }
+    pushScope(reuseTempVariableScope) {
+        this.privateScope = new NameScope(this.privateScope);
+        if (!reuseTempVariableScope)
+            this.scope = new NameScope(this.scope);
+        return true;
+    }
+    popScope(reuseTempVariableScope) {
+        if (this.privateScope !== undefined)
+            this.privateScope = this.privateScope.next;
+        if (!reuseTempVariableScope && this.scope !== undefined)
+            this.scope = this.scope.next;
+        return true;
+    }
+    ensureScope(privateName) {
+        if (privateName) {
+            if (this.privateScope === undefined)
+                this.privateScope = new NameScope(undefined);
+            return this.privateScope;
+        }
+        if (this.scope === undefined)
+            this.scope = new NameScope(undefined);
+        return this.scope;
+    }
+    getTempFlags(privateName, key) {
+        const scope = privateName ? this.privateScope : this.scope;
+        if (scope === undefined)
+            return 0 /* TempFlags.Auto */;
+        if (key.length === 0)
+            return scope.tempFlags;
+        const flags = scope.formattedNameTempFlags === undefined ? undefined : scope.formattedNameTempFlags.get(key);
+        return flags === undefined ? 0 /* TempFlags.Auto */ : flags;
+    }
+    setTempFlags(privateName, key, flags) {
+        const scope = this.ensureScope(privateName);
+        if (key.length === 0)
+            scope.tempFlags = flags;
+        else {
+            if (scope.formattedNameTempFlags === undefined)
+                scope.formattedNameTempFlags = new Map();
+            scope.formattedNameTempFlags.set(key, flags);
+        }
+        return true;
+    }
+    reserveName(name, privateName, scoped, temp) {
+        const scope = this.ensureScope(privateName);
+        if (privateName || scoped) {
+            if (scope.reservedNames === undefined)
+                scope.reservedNames = new Set();
+            scope.reservedNames.add(name);
+        }
+        else if (!temp)
+            this.generatedNames.add(name);
+        return true;
+    }
+    /** The text of a name: generated if it has auto-generate info, else its own text. */
+    generateName(name) {
+        const info = this.context.autoGenerate.get(name);
+        if (info === undefined)
+            return this.host.getTextOfNode(name);
+        if ((info.flags & 7 /* GeneratedIdentifierFlags.KindMask */) === 4 /* GeneratedIdentifierFlags.Node */)
+            return this.generateNameForNodeCached(this.context.getNodeForGeneratedName(name), name instanceof PrivateIdentifier, info.flags, info.prefix, info.suffix);
+        const cached = this.autoGeneratedNames.get(info.id);
+        if (cached !== undefined)
+            return cached;
+        const generated = this.makeName(name);
+        this.autoGeneratedNames.set(info.id, generated);
+        return generated;
+    }
+    generateNameForNodeCached(node, privateName, flags, prefix, suffix) {
+        const cache = privateName ? this.privateNodeNames : this.nodeNames;
+        const cached = cache.get(node);
+        if (cached !== undefined)
+            return cached;
+        const name = this.generateNameForNode(node, privateName, flags, prefix, suffix);
+        cache.set(node, name);
+        return name;
+    }
+    generateNameForNode(node, privateName, flags, prefix, suffix) {
+        switch (node.kind) {
+            case 79 /* SyntaxKind.Identifier */:
+            case 80 /* SyntaxKind.PrivateIdentifier */:
+                return this.makeUniqueName(this.host.getTextOfNode(node), false, (flags & 16 /* GeneratedIdentifierFlags.Optimistic */) !== 0, (flags & 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */) !== 0, privateName, prefix, suffix);
+            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 267 /* SyntaxKind.EnumDeclaration */: {
+                const name = this.host.getTextOfNode(getName(node));
+                if (isUniqueLocalName(name, node))
+                    return name;
+                return this.makeUniqueName(name, false, false, false, false, '', '');
+            }
+            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 346 /* SyntaxKind.JSImportDeclaration */:
+            case 279 /* SyntaxKind.ExportDeclaration */: {
+                const specifier = getExternalModuleName(node);
+                const base = specifier instanceof StringLiteral ? makeIdentifierFromModuleName(specifier.text) : 'module';
+                return this.makeUniqueName(base, false, false, false, false, '', '');
+            }
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 264 /* SyntaxKind.ClassDeclaration */: {
+                const name = getName(node);
+                if (name !== undefined)
+                    return this.generateNameForNode(name, false, flags, '', '');
+                return this.makeUniqueName('default', false, false, false, false, '', '');
+            }
+            case 278 /* SyntaxKind.ExportAssignment */:
+                if (node instanceof ExportAssignment)
+                    return this.makeUniqueName('default', false, false, false, false, '', '');
+                break;
+            case 232 /* SyntaxKind.ClassExpression */:
+                if (node instanceof ClassExpression)
+                    return this.makeUniqueName('class', false, false, false, false, '', '');
+                break;
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */: {
+                const name = getName(node);
+                if (name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */)
+                    return this.generateNameForNodeCached(name, privateName, 0 /* GeneratedIdentifierFlags.None */, prefix, suffix);
+                return this.makeTempVariableName(0 /* TempFlags.Auto */, false, privateName, prefix, suffix);
+            }
+            case 168 /* SyntaxKind.ComputedPropertyName */:
+                return this.makeTempVariableName(0 /* TempFlags.Auto */, true, privateName, prefix, suffix);
+        }
+        return this.makeTempVariableName(0 /* TempFlags.Auto */, false, privateName, prefix, suffix);
+    }
+    makeName(name) {
+        const info = this.context.autoGenerate.get(name);
+        if (info !== undefined) {
+            const reserved = (info.flags & 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */) !== 0;
+            switch (info.flags & 7 /* GeneratedIdentifierFlags.KindMask */) {
+                case 1 /* GeneratedIdentifierFlags.Auto */:
+                    return this.makeTempVariableName(0 /* TempFlags.Auto */, reserved, name instanceof PrivateIdentifier, info.prefix, info.suffix);
+                case 2 /* GeneratedIdentifierFlags.Loop */:
+                    return this.makeTempVariableName(268435456 /* TempFlags.I */, reserved, false, info.prefix, info.suffix);
+                case 3 /* GeneratedIdentifierFlags.Unique */:
+                    return this.makeUniqueName(getText(name), (info.flags & 32 /* GeneratedIdentifierFlags.FileLevel */) !== 0, (info.flags & 16 /* GeneratedIdentifierFlags.Optimistic */) !== 0, reserved, name instanceof PrivateIdentifier, info.prefix, info.suffix);
+            }
+        }
+        return this.host.getTextOfNode(name);
+    }
+    makeTempVariableName(flags, reservedInNestedScopes, privateName, prefix, suffix) {
+        const simple = prefix.length === 0 && suffix.length === 0;
+        let key = '';
+        if (!simple) {
+            key = formatGeneratedName(privateName, prefix, '', suffix);
+            if (privateName)
+                key = ensureLeadingHash(key);
+        }
+        let tempFlags = this.getTempFlags(privateName, key);
+        if (flags !== 0 && (tempFlags & flags) === 0) {
+            const fullName = formatGeneratedName(privateName, prefix, '_i', suffix);
+            if (this.isUniqueName(fullName, privateName)) {
+                tempFlags |= flags;
+                this.reserveName(fullName, privateName, reservedInNestedScopes, true);
+                this.setTempFlags(privateName, key, tempFlags);
+                return fullName;
+            }
+        }
+        for (;;) {
+            const count = tempFlags & 268435455 /* TempFlags.CountMask */;
+            tempFlags++;
+            // Skip `_i` and `_n`.
+            if (count !== 8 && count !== 13) {
+                const name = count < 26 ? '_' + String.fromCharCode(0x61 + count) : '_' + (count - 26);
+                const fullName = formatGeneratedName(privateName, prefix, name, suffix);
+                if (this.isUniqueName(fullName, privateName)) {
+                    this.reserveName(fullName, privateName, reservedInNestedScopes, true);
+                    this.setTempFlags(privateName, key, tempFlags);
+                    return fullName;
+                }
+            }
+        }
+    }
+    makeUniqueName(baseName, fileLevel, optimistic, scoped, privateName, prefix, suffix) {
+        baseName = removeLeadingHash(baseName);
+        if (optimistic) {
+            const fullName = formatGeneratedName(privateName, prefix, baseName, suffix);
+            if (this.checkUniqueName(fullName, privateName, fileLevel)) {
+                this.reserveName(fullName, privateName, scoped, false);
+                return fullName;
+            }
+        }
+        if (baseName.length > 0 && baseName.charCodeAt(baseName.length - 1) !== 0x5f)
+            baseName += '_';
+        for (let i = 1;; i++) {
+            const fullName = formatGeneratedName(privateName, prefix, baseName + i, suffix);
+            if (this.checkUniqueName(fullName, privateName, fileLevel)) {
+                this.reserveName(fullName, privateName, scoped, false);
+                return fullName;
+            }
+        }
+    }
+    makeFileLevelOptimisticUniqueName(name) {
+        return this.makeUniqueName(name, true, true, false, false, '', '');
+    }
+    checkUniqueName(name, privateName, fileLevel) {
+        return fileLevel ? this.host.isFileLevelUniqueName(name) : this.isUniqueName(name, privateName);
+    }
+    isUniqueName(name, privateName) {
+        return this.host.isFileLevelUniqueName(name) && !this.isReservedName(name, privateName);
+    }
+    isReservedName(name, privateName) {
+        if (this.generatedNames.has(name))
+            return true;
+        for (let scope = privateName ? this.privateScope : this.scope; scope !== undefined; scope = scope.next)
+            if (scope.reservedNames !== undefined && scope.reservedNames.has(name))
+                return true;
+        return false;
+    }
+}
+// The names used in recently emitted files, kept apart from the files, which are shared and read-only.
+const identifierSets = new Map();
+/** Forgets the files of earlier emits. */
+export function forgetIdentifierSets() {
+    identifierSets.clear();
+}
+/** Whether no identifier in `file` is named `name`. */
+export function isFileLevelUniqueName(file, name) {
+    let set = identifierSets.get(file);
+    if (set === undefined) {
+        if (identifierSets.size >= 16)
+            identifierSets.clear();
+        set = new Set(file.identifierTexts);
+        identifierSets.set(file, set);
+    }
+    return !set.has(name);
+}