tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/printer/emit-context.js

@@ -0,0 +1,576 @@
+// Side tables that transforms fill in and the printer reads: original nodes, emit flags,
+// comment and source map ranges, synthesized comments, generated names and emit helpers.
+import { ExpressionStatement, FunctionDeclaration, Identifier, NodeList, PrivateIdentifier, StringLiteral, VariableDeclaration, VariableStatement, } from '../ast.js';
+import { NodeFactory } from './factory.js';
+import { isParseTreeNode, isPrologueDirective } from './utilities.js';
+export { EmitHelper, compareEmitHelpers, noPriority } from './helpers.js';
+/** `left` with `right[start:end]` inserted at `at`. */
+function splice(left, at, right, start, end) {
+    const result = left.slice(0, at);
+    for (let i = start; i < end; i++)
+        result.push(right[i]);
+    for (let i = at; i < left.length; i++)
+        result.push(left[i]);
+    return result;
+}
+function prologueText(node) {
+    return node instanceof ExpressionStatement && node.expression instanceof StringLiteral ? node.expression.text : '';
+}
+/** A comment created by a transform rather than read from source text. */
+export class SynthesizedComment {
+    kind;
+    hasLeadingNewLine;
+    hasTrailingNewLine;
+    text;
+    constructor(kind, text, hasLeadingNewLine, hasTrailingNewLine) {
+        this.kind = kind;
+        this.text = text;
+        this.hasLeadingNewLine = hasLeadingNewLine;
+        this.hasTrailingNewLine = hasTrailingNewLine;
+    }
+}
+/** Per-node emit data. */
+class EmitNode {
+    flags;
+    emitFlags;
+    commentPos;
+    commentEnd;
+    sourceMapPos;
+    sourceMapEnd;
+    /** Token kind → [pos, end] ranges of tokens of this node. */
+    tokenSourceMapRanges;
+    helpers;
+    externalHelpersModuleName;
+    leadingComments;
+    trailingComments;
+    /** The type annotation erased from this name, for comment placement. */
+    typeNode;
+    constructor() {
+        this.flags = 0 /* EmitNodeFlags.None */;
+        this.emitFlags = 0 /* EmitFlags.None */;
+        this.commentPos = -1;
+        this.commentEnd = -1;
+        this.sourceMapPos = -1;
+        this.sourceMapEnd = -1;
+        this.tokenSourceMapRanges = undefined;
+        this.helpers = undefined;
+        this.externalHelpersModuleName = undefined;
+        this.leadingComments = undefined;
+        this.trailingComments = undefined;
+        this.typeNode = undefined;
+    }
+    copyFrom(source) {
+        this.flags = source.flags;
+        this.emitFlags = source.emitFlags;
+        this.commentPos = source.commentPos;
+        this.commentEnd = source.commentEnd;
+        this.sourceMapPos = source.sourceMapPos;
+        this.sourceMapEnd = source.sourceMapEnd;
+        const ranges = source.tokenSourceMapRanges;
+        this.tokenSourceMapRanges = ranges === undefined ? undefined : new Map(ranges);
+        this.helpers = source.helpers === undefined ? undefined : source.helpers.slice();
+        this.externalHelpersModuleName = source.externalHelpersModuleName;
+        return this;
+    }
+}
+/** Hoisted declarations collected while transforming a scope. */
+export class VariableScope {
+    variables;
+    functions;
+    flags;
+    initializationStatements;
+    constructor() {
+        this.variables = [];
+        this.functions = [];
+        this.flags = 0 /* EnvironmentFlags.None */;
+        this.initializationStatements = [];
+    }
+}
+export { AutoGenerateInfo, newAutoGenerateId } from './auto-generate.js';
+export class EmitContext extends NodeFactory {
+    autoGenerate;
+    textSource;
+    original;
+    emitNodes;
+    lastLookup;
+    lastEmitNode;
+    assignedNames;
+    classThisNames;
+    varScopes;
+    letScopes;
+    /** Requested unscoped helpers, in request order. */
+    emitHelpers;
+    constructor() {
+        super();
+        this.autoGenerate = new Map();
+        this.textSource = new Map();
+        this.original = new Map();
+        this.emitNodes = new Map();
+        this.lastLookup = undefined;
+        this.lastEmitNode = undefined;
+        this.assignedNames = new Map();
+        this.classThisNames = new Map();
+        this.varScopes = [];
+        this.letScopes = [];
+        this.emitHelpers = [];
+    }
+    /** The factory that creates nodes for this context: the context itself. */
+    get factory() {
+        return this;
+    }
+    get context() {
+        return this;
+    }
+    /**
+     * Gives `node` everything emit knows about `source`: its flags, ranges and synthesized
+     * comments, as if it were the same node.
+     */
+    copyEmitNode(node, source) {
+        const emitNode = this.lookup(source);
+        if (emitNode === undefined)
+            return;
+        const target = this.emitNode(node).copyFrom(emitNode);
+        target.leadingComments = emitNode.leadingComments === undefined ? undefined : emitNode.leadingComments.slice();
+        target.trailingComments = emitNode.trailingComments === undefined ? undefined : emitNode.trailingComments.slice();
+        target.typeNode = emitNode.typeNode;
+    }
+    emitNode(node) {
+        let emitNode = this.lookup(node);
+        if (emitNode === undefined) {
+            emitNode = new EmitNode();
+            this.emitNodes.set(node, emitNode);
+            this.lastLookup = node;
+            this.lastEmitNode = emitNode;
+        }
+        return emitNode;
+    }
+    /** The emit data of `node`. The printer asks for several of a node's in a row, so the last answer is kept. */
+    lookup(node) {
+        if (node === this.lastLookup)
+            return this.lastEmitNode;
+        const emitNode = this.emitNodes.get(node);
+        this.lastLookup = node;
+        this.lastEmitNode = emitNode;
+        return emitNode;
+    }
+    // Original nodes
+    setOriginal(node, original) {
+        this.setOriginalEx(node, original, false);
+    }
+    setOriginalEx(node, original, allowOverwrite) {
+        const existing = this.original.get(node);
+        if (existing === undefined) {
+            this.original.set(node, original);
+            const emitNode = this.lookup(original);
+            if (emitNode !== undefined)
+                this.emitNode(node).copyFrom(emitNode);
+        }
+        else if (allowOverwrite)
+            this.original.set(node, original);
+        else if (existing !== original)
+            throw new Error('Original node already set.');
+    }
+    unsetOriginal(node) {
+        return this.original.delete(node);
+    }
+    getOriginal(node) {
+        return this.original.get(node);
+    }
+    /** The node at the end of the chain of original nodes. */
+    mostOriginal(node) {
+        let original = this.original.get(node);
+        while (original !== undefined) {
+            node = original;
+            original = this.original.get(node);
+        }
+        return node;
+    }
+    /** The parse tree node a node was created from, if any. */
+    parseNode(node) {
+        node = this.mostOriginal(node);
+        return isParseTreeNode(node) ? node : undefined;
+    }
+    // Generated names
+    hasAutoGenerateInfo(node) {
+        return this.autoGenerate.has(node);
+    }
+    getAutoGenerateInfo(node) {
+        return this.autoGenerate.get(node);
+    }
+    /** The node a generated name is based on, following clones of generated names. */
+    getNodeForGeneratedName(name) {
+        const info = this.autoGenerate.get(name);
+        if (info === undefined || (info.flags & 7 /* GeneratedIdentifierFlags.KindMask */) !== 4 /* GeneratedIdentifierFlags.Node */)
+            return name;
+        let node = info.node;
+        const id = info.id;
+        let original = this.original.get(node);
+        while (original !== undefined) {
+            node = original;
+            if (node instanceof Identifier || node instanceof PrivateIdentifier) {
+                const other = this.autoGenerate.get(node);
+                if (other === undefined ||
+                    ((other.flags & 7 /* GeneratedIdentifierFlags.KindMask */) === 4 /* GeneratedIdentifierFlags.Node */ && other.id !== id))
+                    break;
+                if ((other.flags & 7 /* GeneratedIdentifierFlags.KindMask */) === 4 /* GeneratedIdentifierFlags.Node */) {
+                    original = other.node;
+                    continue;
+                }
+            }
+            original = this.original.get(node);
+        }
+        return node;
+    }
+    // Emit data
+    getEmitFlags(node) {
+        const emitNode = this.lookup(node);
+        return emitNode === undefined ? 0 /* EmitFlags.None */ : emitNode.emitFlags;
+    }
+    setEmitFlags(node, flags) {
+        this.emitNode(node).emitFlags = flags;
+        return node;
+    }
+    addEmitFlags(node, flags) {
+        this.emitNode(node).emitFlags |= flags;
+        return node;
+    }
+    commentPos(node) {
+        const emitNode = this.lookup(node);
+        return emitNode !== undefined && (emitNode.flags & 1 /* EmitNodeFlags.HasCommentRange */) !== 0
+            ? emitNode.commentPos
+            : node.pos;
+    }
+    commentEnd(node) {
+        const emitNode = this.lookup(node);
+        return emitNode !== undefined && (emitNode.flags & 1 /* EmitNodeFlags.HasCommentRange */) !== 0
+            ? emitNode.commentEnd
+            : node.end;
+    }
+    setCommentRange(node, pos, end) {
+        const emitNode = this.emitNode(node);
+        emitNode.commentPos = pos;
+        emitNode.commentEnd = end;
+        emitNode.flags |= 1 /* EmitNodeFlags.HasCommentRange */;
+        return node;
+    }
+    assignCommentRange(to, from) {
+        return this.setCommentRange(to, this.commentPos(from), this.commentEnd(from));
+    }
+    sourceMapPos(node) {
+        const emitNode = this.lookup(node);
+        return emitNode !== undefined && (emitNode.flags & 2 /* EmitNodeFlags.HasSourceMapRange */) !== 0
+            ? emitNode.sourceMapPos
+            : node.pos;
+    }
+    sourceMapEnd(node) {
+        const emitNode = this.lookup(node);
+        return emitNode !== undefined && (emitNode.flags & 2 /* EmitNodeFlags.HasSourceMapRange */) !== 0
+            ? emitNode.sourceMapEnd
+            : node.end;
+    }
+    setSourceMapRange(node, pos, end) {
+        const emitNode = this.emitNode(node);
+        emitNode.sourceMapPos = pos;
+        emitNode.sourceMapEnd = end;
+        emitNode.flags |= 2 /* EmitNodeFlags.HasSourceMapRange */;
+        return node;
+    }
+    assignSourceMapRange(to, from) {
+        return this.setSourceMapRange(to, this.sourceMapPos(from), this.sourceMapEnd(from));
+    }
+    assignCommentAndSourceMapRanges(to, from) {
+        const commentPos = this.commentPos(from);
+        const commentEnd = this.commentEnd(from);
+        const sourceMapPos = this.sourceMapPos(from);
+        const sourceMapEnd = this.sourceMapEnd(from);
+        const emitNode = this.emitNode(to);
+        emitNode.commentPos = commentPos;
+        emitNode.commentEnd = commentEnd;
+        emitNode.sourceMapPos = sourceMapPos;
+        emitNode.sourceMapEnd = sourceMapEnd;
+        emitNode.flags |= 1 /* EmitNodeFlags.HasCommentRange */ | 2 /* EmitNodeFlags.HasSourceMapRange */;
+        return to;
+    }
+    /** The `[pos, end]` source map range of a token of `node`, if one was set. */
+    tokenSourceMapRange(node, kind) {
+        const emitNode = this.lookup(node);
+        if (emitNode === undefined || emitNode.tokenSourceMapRanges === undefined)
+            return undefined;
+        return emitNode.tokenSourceMapRanges.get(kind);
+    }
+    setTokenSourceMapRange(node, kind, pos, end) {
+        const emitNode = this.emitNode(node);
+        let ranges = emitNode.tokenSourceMapRanges;
+        if (ranges === undefined) {
+            ranges = new Map();
+            emitNode.tokenSourceMapRanges = ranges;
+        }
+        ranges.set(kind, [pos, end]);
+        return node;
+    }
+    getAssignedName(node) {
+        return this.assignedNames.get(node);
+    }
+    setAssignedName(node, name) {
+        this.assignedNames.set(node, name);
+        return node;
+    }
+    getClassThis(node) {
+        return this.classThisNames.get(node);
+    }
+    setClassThis(node, classThis) {
+        this.classThisNames.set(node, classThis);
+        return node;
+    }
+    getTextSource(node) {
+        return this.textSource.get(node);
+    }
+    setTextSource(node, source) {
+        this.textSource.set(node, source);
+        return node;
+    }
+    getTypeNode(node) {
+        const emitNode = this.lookup(node);
+        return emitNode === undefined ? undefined : emitNode.typeNode;
+    }
+    /** Keeps the erased type annotation of a name so its comments can still be emitted. */
+    setTypeNode(node, typeNode) {
+        this.emitNode(node).typeNode = typeNode;
+        return node;
+    }
+    // Synthesized comments
+    getSyntheticLeadingComments(node) {
+        const emitNode = this.lookup(node);
+        return emitNode === undefined ? undefined : emitNode.leadingComments;
+    }
+    setSyntheticLeadingComments(node, comments) {
+        this.emitNode(node).leadingComments = comments;
+        return node;
+    }
+    addSyntheticLeadingComment(node, kind, text, hasTrailingNewLine) {
+        const emitNode = this.emitNode(node);
+        if (emitNode.leadingComments === undefined)
+            emitNode.leadingComments = [];
+        emitNode.leadingComments.push(new SynthesizedComment(kind, text, false, hasTrailingNewLine));
+        return node;
+    }
+    getSyntheticTrailingComments(node) {
+        const emitNode = this.lookup(node);
+        return emitNode === undefined ? undefined : emitNode.trailingComments;
+    }
+    setSyntheticTrailingComments(node, comments) {
+        this.emitNode(node).trailingComments = comments;
+        return node;
+    }
+    addSyntheticTrailingComment(node, kind, text, hasTrailingNewLine) {
+        const emitNode = this.emitNode(node);
+        if (emitNode.trailingComments === undefined)
+            emitNode.trailingComments = [];
+        emitNode.trailingComments.push(new SynthesizedComment(kind, text, false, hasTrailingNewLine));
+        return node;
+    }
+    // Emit helpers
+    requestEmitHelper(helper) {
+        if (helper.scoped)
+            throw new Error('Cannot request a scoped emit helper');
+        for (const dependency of helper.dependencies)
+            this.requestEmitHelper(dependency);
+        if (this.emitHelpers.indexOf(helper) < 0)
+            this.emitHelpers.push(helper);
+        return helper;
+    }
+    readEmitHelpers() {
+        const helpers = this.emitHelpers.slice();
+        this.emitHelpers.length = 0;
+        return helpers;
+    }
+    addEmitHelper(node, helper) {
+        const emitNode = this.emitNode(node);
+        if (emitNode.helpers === undefined)
+            emitNode.helpers = [];
+        if (emitNode.helpers.indexOf(helper) < 0)
+            emitNode.helpers.push(helper);
+        return node;
+    }
+    getEmitHelpers(node) {
+        const emitNode = this.lookup(node);
+        return emitNode === undefined ? undefined : emitNode.helpers;
+    }
+    getExternalHelpersModuleName(file) {
+        const parseNode = this.parseNode(file);
+        if (parseNode === undefined)
+            return undefined;
+        const emitNode = this.lookup(parseNode);
+        return emitNode === undefined ? undefined : emitNode.externalHelpersModuleName;
+    }
+    setExternalHelpersModuleName(file, name) {
+        const parseNode = this.parseNode(file);
+        if (parseNode === undefined)
+            throw new Error('Node must be a parse tree node or have an original parse tree node.');
+        this.emitNode(parseNode).externalHelpersModuleName = name;
+        return name;
+    }
+    hasRecordedExternalHelpers(file) {
+        const parseNode = this.parseNode(file);
+        if (parseNode === undefined)
+            return false;
+        const emitNode = this.lookup(parseNode);
+        return (emitNode !== undefined &&
+            (emitNode.externalHelpersModuleName !== undefined || (emitNode.emitFlags & 262144 /* EmitFlags.ExternalHelpers */) !== 0));
+    }
+    // Hoisted declarations
+    /** Starts collecting hoisted `var` and function declarations (and a lexical scope). */
+    startVariableEnvironment() {
+        const scope = new VariableScope();
+        this.varScopes.push(scope);
+        this.startLexicalEnvironment();
+        return scope;
+    }
+    /** Ends the current variable environment, returning the statements to add at the start of its scope. */
+    endVariableEnvironment() {
+        const scope = this.varScopes.pop();
+        const factory = this.factory;
+        const statements = scope.functions.slice();
+        if (scope.variables.length > 0) {
+            const statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList(scope.variables), 0));
+            this.setEmitFlags(statement, 65536 /* EmitFlags.CustomPrologue */);
+            statements.push(statement);
+        }
+        for (const statement of scope.initializationStatements)
+            statements.push(statement);
+        const lexical = this.endLexicalEnvironment();
+        for (const statement of lexical)
+            statements.push(statement);
+        return statements;
+    }
+    startLexicalEnvironment() {
+        const scope = new VariableScope();
+        this.letScopes.push(scope);
+        return scope;
+    }
+    endLexicalEnvironment() {
+        const scope = this.letScopes.pop();
+        const statements = [];
+        if (scope.variables.length > 0) {
+            const factory = this.factory;
+            const statement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList(scope.variables), 1 /* NodeFlags.Let */));
+            this.setEmitFlags(statement, 65536 /* EmitFlags.CustomPrologue */);
+            statements.push(statement);
+        }
+        return statements;
+    }
+    /** Adds a `var` declaration to the current variable environment. */
+    addVariableDeclaration(name) {
+        const declaration = this.factory.createVariableDeclaration(name, undefined, undefined, undefined);
+        this.setEmitFlags(declaration, 16 /* EmitFlags.NoNestedSourceMaps */);
+        const scope = this.varScopes[this.varScopes.length - 1];
+        scope.variables.push(declaration);
+        if ((scope.flags & 1 /* EnvironmentFlags.InParameters */) !== 0)
+            scope.flags |= 2 /* EnvironmentFlags.VariablesHoistedInParameters */;
+        return name;
+    }
+    /** Adds a `let` declaration to the current lexical environment. */
+    addLexicalDeclaration(name) {
+        const declaration = this.factory.createVariableDeclaration(name, undefined, undefined, undefined);
+        this.setEmitFlags(declaration, 16 /* EmitFlags.NoNestedSourceMaps */);
+        this.letScopes[this.letScopes.length - 1].variables.push(declaration);
+        return name;
+    }
+    addHoistedFunctionDeclaration(node) {
+        this.setEmitFlags(node, 65536 /* EmitFlags.CustomPrologue */);
+        this.varScopes[this.varScopes.length - 1].functions.push(node);
+        return node;
+    }
+    addInitializationStatement(node) {
+        if (this.varScopes.length === 0)
+            throw new Error('Tried to add an initialization statement without a surrounding variable scope');
+        this.addEmitFlags(node, 65536 /* EmitFlags.CustomPrologue */);
+        this.varScopes[this.varScopes.length - 1].initializationStatements.push(node);
+        return node;
+    }
+    /** Marks the current variable scope as visiting parameters; returns the previous flags. */
+    enterParameters() {
+        const scope = this.varScopes[this.varScopes.length - 1];
+        const flags = scope.flags;
+        scope.flags |= 1 /* EnvironmentFlags.InParameters */;
+        return flags;
+    }
+    /** Restores the scope flags; returns whether a variable was hoisted while visiting the parameters. */
+    exitParameters(previousFlags) {
+        const scope = this.varScopes[this.varScopes.length - 1];
+        const hoisted = (scope.flags & 2 /* EnvironmentFlags.VariablesHoistedInParameters */) !== 0;
+        scope.flags = previousFlags;
+        return hoisted;
+    }
+    /** `statements` with `declarations` from an ended environment merged in, keeping the list's range. */
+    mergeEnvironmentList(statements, declarations) {
+        const merged = this.mergeEnvironment(statements.nodes, declarations);
+        return merged === statements.nodes ? statements : new NodeList(statements.pos, statements.end, merged);
+    }
+    /**
+     * Merges hoisted declarations into statements: prologue directives, then hoisted functions,
+     * hoisted variables and other custom prologues, the new ones before the existing ones of each group.
+     */
+    mergeEnvironment(statements, declarations) {
+        if (declarations.length === 0)
+            return statements;
+        const leftPrologueEnd = this.spanEnd(statements, 0, 0 /* SpanKind.Prologue */);
+        const leftFunctionsEnd = this.spanEnd(statements, leftPrologueEnd, 1 /* SpanKind.HoistedFunction */);
+        const leftVariablesEnd = this.spanEnd(statements, leftFunctionsEnd, 2 /* SpanKind.HoistedVariable */);
+        const rightPrologueEnd = this.spanEnd(declarations, 0, 0 /* SpanKind.Prologue */);
+        const rightFunctionsEnd = this.spanEnd(declarations, rightPrologueEnd, 1 /* SpanKind.HoistedFunction */);
+        const rightVariablesEnd = this.spanEnd(declarations, rightFunctionsEnd, 2 /* SpanKind.HoistedVariable */);
+        const rightCustomEnd = this.spanEnd(declarations, rightVariablesEnd, 3 /* SpanKind.CustomPrologue */);
+        if (rightCustomEnd !== declarations.length)
+            throw new Error('Expected declarations to be valid standard or custom prologues');
+        let left = statements;
+        if (rightCustomEnd > rightVariablesEnd)
+            left = splice(left, leftVariablesEnd, declarations, rightVariablesEnd, rightCustomEnd);
+        if (rightVariablesEnd > rightFunctionsEnd)
+            left = splice(left, leftFunctionsEnd, declarations, rightFunctionsEnd, rightVariablesEnd);
+        if (rightFunctionsEnd > rightPrologueEnd)
+            left = splice(left, leftPrologueEnd, declarations, rightPrologueEnd, rightFunctionsEnd);
+        if (rightPrologueEnd > 0) {
+            if (leftPrologueEnd === 0)
+                left = splice(left, 0, declarations, 0, rightPrologueEnd);
+            else {
+                const existing = new Set();
+                for (let i = 0; i < leftPrologueEnd; i++)
+                    existing.add(prologueText(statements[i]));
+                for (let i = rightPrologueEnd - 1; i >= 0; i--) {
+                    const declaration = declarations[i];
+                    if (!existing.has(prologueText(declaration)))
+                        left = [declaration].concat(left);
+                }
+            }
+        }
+        return left;
+    }
+    spanEnd(nodes, start, kind) {
+        let i = start;
+        while (i < nodes.length && this.isSpanKind(nodes[i], kind))
+            i++;
+        return i;
+    }
+    isSpanKind(node, kind) {
+        switch (kind) {
+            case 0 /* SpanKind.Prologue */:
+                return isPrologueDirective(node);
+            case 1 /* SpanKind.HoistedFunction */:
+                return this.isCustomPrologue(node) && node instanceof FunctionDeclaration;
+            case 2 /* SpanKind.HoistedVariable */:
+                if (!this.isCustomPrologue(node) || !(node instanceof VariableStatement))
+                    return false;
+                for (const declaration of node.declarationList.declarations.nodes)
+                    if (!(declaration instanceof VariableDeclaration) ||
+                        !(declaration.name instanceof Identifier) ||
+                        declaration.initializer !== undefined)
+                        return false;
+                return true;
+        }
+        return this.isCustomPrologue(node);
+    }
+    isCustomPrologue(node) {
+        return (this.getEmitFlags(node) & 65536 /* EmitFlags.CustomPrologue */) !== 0;
+    }
+}

package/dist/api/compiler/printer/emit-flags.d.ts

@@ -0,0 +1,60 @@
+export declare const enum EmitFlags {
+    None = 0,
+    /** Emit the node's contents on a single line. */
+    SingleLine = 1,
+    /** Emit the node's contents on multiple lines. */
+    MultiLine = 2,
+    NoLeadingSourceMap = 4,
+    NoTrailingSourceMap = 8,
+    /** No source map locations for children. */
+    NoNestedSourceMaps = 16,
+    NoTokenLeadingSourceMaps = 32,
+    NoTokenTrailingSourceMaps = 64,
+    NoLeadingComments = 128,
+    NoTrailingComments = 256,
+    /** No comments for children. */
+    NoNestedComments = 512,
+    /** The identifier names an unscoped emit helper. */
+    HelperName = 1024,
+    /** Prefix the identifier with its export (for exported declarations with a local name). */
+    ExportName = 2048,
+    /** Don't prefix the identifier with its export. */
+    LocalName = 4096,
+    /** Indent class and function bodies one more level. */
+    Indented = 8192,
+    NoIndentation = 16384,
+    ReuseTempVariableScope = 32768,
+    /** Treat the statement as a prologue directive. */
+    CustomPrologue = 65536,
+    /** Escape non-ASCII characters of a synthesized literal. */
+    NoAsciiEscaping = 131072,
+    ExternalHelpers = 262144,
+    StartOnNewLine = 524288,
+    /** Emit a call as `(0, f)()`. */
+    IndirectCall = 1048576,
+    AsyncFunctionBody = 2097152,
+    NoLexicalArguments = 4194304,
+    TransformPrivateStaticElements = 8388608,
+    NoLexicalThis = 16777216,
+    NoSourceMap = 12,
+    NoTokenSourceMaps = 96,
+    NoComments = 384
+}
+export declare const enum GeneratedIdentifierFlags {
+    None = 0,
+    /** A temporary variable such as `_a`. */
+    Auto = 1,
+    /** A loop variable, preferring `_i`. */
+    Loop = 2,
+    /** A unique name based on the identifier's text. */
+    Unique = 3,
+    /** A unique name based on another node. */
+    Node = 4,
+    KindMask = 7,
+    ReservedInNestedScopes = 8,
+    /** The first instance doesn't get a `_1` suffix if there's no conflict. */
+    Optimistic = 16,
+    /** Check conflicts only against the file's identifiers. */
+    FileLevel = 32,
+    AllowNameSubstitution = 64
+}

package/dist/api/compiler/printer/emit-flags.js

@@ -0,0 +1,2 @@
+// Flags transforms set on nodes to customize how the printer emits them.
+export {};