tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/printer/async-helpers.d.ts

@@ -0,0 +1,22 @@
+import { type CallExpression, type Node, type NodeList } from '../ast.js';
+import type { NodeFactory } from './factory.js';
+import { EmitHelper } from './helpers.js';
+export declare const awaitHelper: EmitHelper;
+export declare const asyncGeneratorHelper: EmitHelper;
+export declare const asyncDelegatorHelper: EmitHelper;
+export declare const asyncValuesHelper: EmitHelper;
+export declare const awaiterHelper: EmitHelper;
+/** Scoped: `const _superIndex = name => super[name];` */
+export declare const asyncSuperHelper: EmitHelper;
+/** Scoped: a `_superIndex` whose results can also be assigned to. */
+export declare const advancedAsyncSuperHelper: EmitHelper;
+/** `__await(expression)` */
+export declare function createAwaitHelper(factory: NodeFactory, expression: Node): CallExpression;
+/** `__asyncGenerator(this, arguments, generatorFunc)` */
+export declare function createAsyncGeneratorHelper(factory: NodeFactory, generatorFunc: Node, hasLexicalThis: boolean): CallExpression;
+/** `__asyncDelegator(expression)` */
+export declare function createAsyncDelegatorHelper(factory: NodeFactory, expression: Node): CallExpression;
+/** `__asyncValues(expression)` */
+export declare function createAsyncValuesHelper(factory: NodeFactory, expression: Node): CallExpression;
+/** `__awaiter(this, arguments, void 0, function* (parameters) { body })` */
+export declare function createAwaiterHelper(factory: NodeFactory, hasLexicalThis: boolean, argumentsExpression: Node | undefined, parameters: NodeList | undefined, body: Node): CallExpression;

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

@@ -0,0 +1,91 @@
+// Runtime helpers for lowering async functions, async generators and `for await`.
+import { FunctionExpression } from '../ast.js';
+import { EmitHelper, noPriority } from './helpers.js';
+export const awaitHelper = new EmitHelper('typescript:await', false, `var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }`, noPriority, [], '__await', '');
+export const asyncGeneratorHelper = new EmitHelper('typescript:asyncGenerator', false, `var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};`, noPriority, [awaitHelper], '__asyncGenerator', '');
+export const asyncDelegatorHelper = new EmitHelper('typescript:asyncDelegator', false, `var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
+};`, noPriority, [awaitHelper], '__asyncDelegator', '');
+export const asyncValuesHelper = new EmitHelper('typescript:asyncValues', false, `var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};`, noPriority, [], '__asyncValues', '');
+export const awaiterHelper = new EmitHelper('typescript:awaiter', false, `var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};`, 5, [], '__awaiter', '');
+/** Scoped: `const _superIndex = name => super[name];` */
+export const asyncSuperHelper = new EmitHelper('typescript:async-super', true, '\nconst {name} = name => super[name];', noPriority, [], '', '_superIndex');
+/** Scoped: a `_superIndex` whose results can also be assigned to. */
+export const advancedAsyncSuperHelper = new EmitHelper('typescript:advanced-async-super', true, '\nconst {name} = (function (geti, seti) {\n' +
+    '    const cache = Object.create(null);\n' +
+    '    return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n' +
+    '})(name => super[name], (name, value) => super[name] = value);', noPriority, [], '', '_superIndex');
+/** `__await(expression)` */
+export function createAwaitHelper(factory, expression) {
+    factory.context.requestEmitHelper(awaitHelper);
+    return factory.createCallExpression(factory.createUnscopedHelperName('__await'), [expression]);
+}
+/** `__asyncGenerator(this, arguments, generatorFunc)` */
+export function createAsyncGeneratorHelper(factory, generatorFunc, hasLexicalThis) {
+    factory.context.requestEmitHelper(awaitHelper);
+    factory.context.requestEmitHelper(asyncGeneratorHelper);
+    factory.context.addEmitFlags(generatorFunc, 2097152 /* EmitFlags.AsyncFunctionBody */ | 32768 /* EmitFlags.ReuseTempVariableScope */);
+    const thisArg = createThisArgument(factory, hasLexicalThis);
+    return factory.createCallExpression(factory.createUnscopedHelperName('__asyncGenerator'), [
+        thisArg,
+        factory.createIdentifier('arguments'),
+        generatorFunc,
+    ]);
+}
+/** `__asyncDelegator(expression)` */
+export function createAsyncDelegatorHelper(factory, expression) {
+    factory.context.requestEmitHelper(awaitHelper);
+    factory.context.requestEmitHelper(asyncDelegatorHelper);
+    return factory.createCallExpression(factory.createUnscopedHelperName('__asyncDelegator'), [expression]);
+}
+/** `__asyncValues(expression)` */
+export function createAsyncValuesHelper(factory, expression) {
+    factory.context.requestEmitHelper(asyncValuesHelper);
+    return factory.createCallExpression(factory.createUnscopedHelperName('__asyncValues'), [expression]);
+}
+/** `__awaiter(this, arguments, void 0, function* (parameters) { body })` */
+export function createAwaiterHelper(factory, hasLexicalThis, argumentsExpression, parameters, body) {
+    factory.context.requestEmitHelper(awaiterHelper);
+    const generatorFunc = factory.created(new FunctionExpression(undefined, factory.createToken(41 /* SyntaxKind.AsteriskToken */), undefined, undefined, parameters !== undefined ? parameters : factory.createNodeList([]), undefined, undefined, body));
+    factory.context.addEmitFlags(generatorFunc, 2097152 /* EmitFlags.AsyncFunctionBody */ | 32768 /* EmitFlags.ReuseTempVariableScope */);
+    const thisArg = createThisArgument(factory, hasLexicalThis);
+    return factory.createCallExpression(factory.createUnscopedHelperName('__awaiter'), [
+        thisArg,
+        argumentsExpression !== undefined ? argumentsExpression : factory.createVoidZero(),
+        factory.createVoidZero(),
+        generatorFunc,
+    ]);
+}
+/** `this` when the function has a lexical `this`, else `void 0`. */
+function createThisArgument(factory, hasLexicalThis) {
+    if (hasLexicalThis)
+        return factory.createKeywordExpression(109 /* SyntaxKind.ThisKeyword */);
+    return factory.createVoidZero();
+}

package/dist/api/compiler/printer/auto-generate.d.ts

@@ -0,0 +1,13 @@
+import type { Node } from '../ast.js';
+import type { GeneratedIdentifierFlags } from './emit-flags.js';
+export declare class AutoGenerateInfo {
+    readonly flags: GeneratedIdentifierFlags;
+    /** Generated names with the same id print the same text; clones keep it. */
+    readonly id: number;
+    readonly prefix: string;
+    readonly suffix: string;
+    /** For `GeneratedIdentifierFlags.Node`, the node the name is generated from. */
+    readonly node: Node | undefined;
+    constructor(flags: GeneratedIdentifierFlags, id: number, prefix: string, suffix: string, node: Node | undefined);
+}
+export declare function newAutoGenerateId(): number;

package/dist/api/compiler/printer/auto-generate.js

@@ -0,0 +1,20 @@
+export class AutoGenerateInfo {
+    flags;
+    /** Generated names with the same id print the same text; clones keep it. */
+    id;
+    prefix;
+    suffix;
+    /** For `GeneratedIdentifierFlags.Node`, the node the name is generated from. */
+    node;
+    constructor(flags, id, prefix, suffix, node) {
+        this.flags = flags;
+        this.id = id;
+        this.prefix = prefix;
+        this.suffix = suffix;
+        this.node = node;
+    }
+}
+let nextAutoGenerateId = 1;
+export function newAutoGenerateId() {
+    return nextAutoGenerateId++;
+}

package/dist/api/compiler/printer/decorator-helpers.d.ts

@@ -0,0 +1,24 @@
+import { type CallExpression, type Node } from '../ast.js';
+import type { NodeFactory } from './factory.js';
+import { EmitHelper } from './helpers.js';
+export declare const decorateHelper: EmitHelper;
+export declare const metadataHelper: EmitHelper;
+export declare const paramHelper: EmitHelper;
+export declare const esDecorateHelper: EmitHelper;
+export declare const runInitializersHelper: EmitHelper;
+export declare const propKeyHelper: EmitHelper;
+export declare const setFunctionNameHelper: EmitHelper;
+/** `__decorate([decorators], target, memberName, descriptor)`; the member name and descriptor are optional. */
+export declare function createDecorateHelper(factory: NodeFactory, decorators: Node[], target: Node, memberName: Node | undefined, descriptor: Node | undefined): CallExpression;
+/** `__metadata("key", value)` */
+export declare function createMetadataHelper(factory: NodeFactory, key: string, value: Node): CallExpression;
+/** `__param(index, decorator)`, with the range of the decorator. */
+export declare function createParamHelper(factory: NodeFactory, expression: Node, parameterOffset: number, pos: number, end: number): CallExpression;
+/** `__esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers)` */
+export declare function createESDecorateHelper(factory: NodeFactory, ctor: Node, descriptorIn: Node, decorators: Node, contextIn: Node, initializers: Node, extraInitializers: Node): CallExpression;
+/** `__runInitializers(thisArg, initializers, value)`; the value is optional. */
+export declare function createRunInitializersHelper(factory: NodeFactory, thisArg: Node, initializers: Node, value: Node | undefined): CallExpression;
+/** `__propKey(expression)` */
+export declare function createPropKeyHelper(factory: NodeFactory, expression: Node): CallExpression;
+/** `__setFunctionName(fn, name, "prefix")`; an empty prefix is omitted. */
+export declare function createSetFunctionNameHelper(factory: NodeFactory, fn: Node, name: Node, prefix: string): CallExpression;

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

@@ -0,0 +1,118 @@
+// Runtime helpers for legacy (`experimentalDecorators`) and standard decorators, and the
+// function-naming helpers class transforms share.
+import { ArrayLiteralExpression } from '../ast.js';
+import { EmitHelper, noPriority } from './helpers.js';
+export const decorateHelper = new EmitHelper('typescript:decorate', false, `var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};`, 2, [], '__decorate', '');
+export const metadataHelper = new EmitHelper('typescript:metadata', false, `var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};`, 3, [], '__metadata', '');
+export const paramHelper = new EmitHelper('typescript:param', false, `var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};`, 4, [], '__param', '');
+export const esDecorateHelper = new EmitHelper('typescript:esDecorate', false, `var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};`, 2, [], '__esDecorate', '');
+export const runInitializersHelper = new EmitHelper('typescript:runInitializers', false, `var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};`, 2, [], '__runInitializers', '');
+export const propKeyHelper = new EmitHelper('typescript:propKey', false, `var __propKey = (this && this.__propKey) || function (x) {
+    return typeof x === "symbol" ? x : "".concat(x);
+};`, noPriority, [], '__propKey', '');
+export const setFunctionNameHelper = new EmitHelper('typescript:setFunctionName', false, `var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};`, noPriority, [], '__setFunctionName', '');
+/** `__decorate([decorators], target, memberName, descriptor)`; the member name and descriptor are optional. */
+export function createDecorateHelper(factory, decorators, target, memberName, descriptor) {
+    factory.context.requestEmitHelper(decorateHelper);
+    const args = [factory.created(new ArrayLiteralExpression(factory.createNodeList(decorators), true)), target];
+    if (memberName !== undefined) {
+        args.push(memberName);
+        if (descriptor !== undefined)
+            args.push(descriptor);
+    }
+    return factory.createCallExpression(factory.createUnscopedHelperName('__decorate'), args);
+}
+/** `__metadata("key", value)` */
+export function createMetadataHelper(factory, key, value) {
+    factory.context.requestEmitHelper(metadataHelper);
+    return factory.createCallExpression(factory.createUnscopedHelperName('__metadata'), [
+        factory.createStringLiteral(key, 0 /* TokenFlags.None */),
+        value,
+    ]);
+}
+/** `__param(index, decorator)`, with the range of the decorator. */
+export function createParamHelper(factory, expression, parameterOffset, pos, end) {
+    factory.context.requestEmitHelper(paramHelper);
+    const helper = factory.createCallExpression(factory.createUnscopedHelperName('__param'), [
+        factory.createNumericLiteral(String(parameterOffset)),
+        expression,
+    ]);
+    helper.pos = pos | 0;
+    helper.end = end | 0;
+    return helper;
+}
+/** `__esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers)` */
+export function createESDecorateHelper(factory, ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    factory.context.requestEmitHelper(esDecorateHelper);
+    return factory.createCallExpression(factory.createUnscopedHelperName('__esDecorate'), [
+        ctor,
+        descriptorIn,
+        decorators,
+        contextIn,
+        initializers,
+        extraInitializers,
+    ]);
+}
+/** `__runInitializers(thisArg, initializers, value)`; the value is optional. */
+export function createRunInitializersHelper(factory, thisArg, initializers, value) {
+    factory.context.requestEmitHelper(runInitializersHelper);
+    const args = value !== undefined ? [thisArg, initializers, value] : [thisArg, initializers];
+    return factory.createCallExpression(factory.createUnscopedHelperName('__runInitializers'), args);
+}
+/** `__propKey(expression)` */
+export function createPropKeyHelper(factory, expression) {
+    factory.context.requestEmitHelper(propKeyHelper);
+    return factory.createCallExpression(factory.createUnscopedHelperName('__propKey'), [expression]);
+}
+/** `__setFunctionName(fn, name, "prefix")`; an empty prefix is omitted. */
+export function createSetFunctionNameHelper(factory, fn, name, prefix) {
+    factory.context.requestEmitHelper(setFunctionNameHelper);
+    const args = [fn, name];
+    if (prefix.length > 0)
+        args.push(factory.createStringLiteral(prefix, 0 /* TokenFlags.None */));
+    return factory.createCallExpression(factory.createUnscopedHelperName('__setFunctionName'), args);
+}

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

@@ -0,0 +1,154 @@
+import { FunctionDeclaration, Identifier, type Node, NodeList, SourceFile } from '../ast.js';
+import { SyntaxKind } from '../syntax-kind.js';
+import { EmitFlags } from './emit-flags.js';
+import { AutoGenerateInfo } from './auto-generate.js';
+import { NodeFactory } from './factory.js';
+import type { EmitHelper } from './helpers.js';
+export { EmitHelper, compareEmitHelpers, noPriority } from './helpers.js';
+/** A comment created by a transform rather than read from source text. */
+export declare class SynthesizedComment {
+    readonly kind: SyntaxKind;
+    readonly hasLeadingNewLine: boolean;
+    readonly hasTrailingNewLine: boolean;
+    readonly text: string;
+    constructor(kind: SyntaxKind, text: string, hasLeadingNewLine: boolean, hasTrailingNewLine: boolean);
+}
+declare const enum EmitNodeFlags {
+    None = 0,
+    HasCommentRange = 1,
+    HasSourceMapRange = 2
+}
+/** Per-node emit data. */
+declare class EmitNode {
+    flags: EmitNodeFlags;
+    emitFlags: EmitFlags;
+    commentPos: number;
+    commentEnd: number;
+    sourceMapPos: number;
+    sourceMapEnd: number;
+    /** Token kind → [pos, end] ranges of tokens of this node. */
+    tokenSourceMapRanges: Map<SyntaxKind, number[]> | undefined;
+    helpers: EmitHelper[] | undefined;
+    externalHelpersModuleName: Identifier | undefined;
+    leadingComments: SynthesizedComment[] | undefined;
+    trailingComments: SynthesizedComment[] | undefined;
+    /** The type annotation erased from this name, for comment placement. */
+    typeNode: Node | undefined;
+    constructor();
+    copyFrom(source: EmitNode): EmitNode;
+}
+declare const enum EnvironmentFlags {
+    None = 0,
+    InParameters = 1,
+    VariablesHoistedInParameters = 2
+}
+/** Hoisted declarations collected while transforming a scope. */
+export declare class VariableScope {
+    variables: Node[];
+    functions: Node[];
+    flags: EnvironmentFlags;
+    initializationStatements: Node[];
+    constructor();
+}
+export { AutoGenerateInfo, newAutoGenerateId } from './auto-generate.js';
+export declare class EmitContext extends NodeFactory {
+    readonly autoGenerate: Map<Node, AutoGenerateInfo>;
+    readonly textSource: Map<Node, Node>;
+    readonly original: Map<Node, Node>;
+    readonly emitNodes: Map<Node, EmitNode>;
+    private lastLookup;
+    private lastEmitNode;
+    readonly assignedNames: Map<Node, Node>;
+    readonly classThisNames: Map<Node, Node>;
+    readonly varScopes: VariableScope[];
+    readonly letScopes: VariableScope[];
+    /** Requested unscoped helpers, in request order. */
+    readonly emitHelpers: EmitHelper[];
+    constructor();
+    /** The factory that creates nodes for this context: the context itself. */
+    get factory(): NodeFactory;
+    get context(): EmitContext;
+    /**
+     * Gives `node` everything emit knows about `source`: its flags, ranges and synthesized
+     * comments, as if it were the same node.
+     */
+    copyEmitNode(node: Node, source: Node): void;
+    private emitNode;
+    /** The emit data of `node`. The printer asks for several of a node's in a row, so the last answer is kept. */
+    private lookup;
+    setOriginal(node: Node, original: Node): void;
+    setOriginalEx(node: Node, original: Node, allowOverwrite: boolean): void;
+    unsetOriginal(node: Node): boolean;
+    getOriginal(node: Node): Node | undefined;
+    /** The node at the end of the chain of original nodes. */
+    mostOriginal(node: Node): Node;
+    /** The parse tree node a node was created from, if any. */
+    parseNode(node: Node): Node | undefined;
+    hasAutoGenerateInfo(node: Node): boolean;
+    getAutoGenerateInfo(node: Node): AutoGenerateInfo | undefined;
+    /** The node a generated name is based on, following clones of generated names. */
+    getNodeForGeneratedName(name: Node): Node;
+    getEmitFlags(node: Node): EmitFlags;
+    setEmitFlags(node: Node, flags: EmitFlags): Node;
+    addEmitFlags(node: Node, flags: EmitFlags): Node;
+    commentPos(node: Node): number;
+    commentEnd(node: Node): number;
+    setCommentRange(node: Node, pos: number, end: number): Node;
+    assignCommentRange(to: Node, from: Node): Node;
+    sourceMapPos(node: Node): number;
+    sourceMapEnd(node: Node): number;
+    setSourceMapRange(node: Node, pos: number, end: number): Node;
+    assignSourceMapRange(to: Node, from: Node): Node;
+    assignCommentAndSourceMapRanges(to: Node, from: Node): Node;
+    /** The `[pos, end]` source map range of a token of `node`, if one was set. */
+    tokenSourceMapRange(node: Node, kind: SyntaxKind): number[] | undefined;
+    setTokenSourceMapRange(node: Node, kind: SyntaxKind, pos: number, end: number): Node;
+    getAssignedName(node: Node): Node | undefined;
+    setAssignedName(node: Node, name: Node): Node;
+    getClassThis(node: Node): Node | undefined;
+    setClassThis(node: Node, classThis: Node): Node;
+    getTextSource(node: Node): Node | undefined;
+    setTextSource(node: Node, source: Node): Node;
+    getTypeNode(node: Node): Node | undefined;
+    /** Keeps the erased type annotation of a name so its comments can still be emitted. */
+    setTypeNode(node: Node, typeNode: Node): Node;
+    getSyntheticLeadingComments(node: Node): SynthesizedComment[] | undefined;
+    setSyntheticLeadingComments(node: Node, comments: SynthesizedComment[] | undefined): Node;
+    addSyntheticLeadingComment(node: Node, kind: SyntaxKind, text: string, hasTrailingNewLine: boolean): Node;
+    getSyntheticTrailingComments(node: Node): SynthesizedComment[] | undefined;
+    setSyntheticTrailingComments(node: Node, comments: SynthesizedComment[] | undefined): Node;
+    addSyntheticTrailingComment(node: Node, kind: SyntaxKind, text: string, hasTrailingNewLine: boolean): Node;
+    requestEmitHelper(helper: EmitHelper): EmitHelper;
+    readEmitHelpers(): EmitHelper[];
+    addEmitHelper(node: Node, helper: EmitHelper): Node;
+    getEmitHelpers(node: Node): EmitHelper[] | undefined;
+    getExternalHelpersModuleName(file: SourceFile): Identifier | undefined;
+    setExternalHelpersModuleName(file: SourceFile, name: Identifier): Identifier;
+    hasRecordedExternalHelpers(file: SourceFile): boolean;
+    /** Starts collecting hoisted `var` and function declarations (and a lexical scope). */
+    startVariableEnvironment(): VariableScope;
+    /** Ends the current variable environment, returning the statements to add at the start of its scope. */
+    endVariableEnvironment(): Node[];
+    startLexicalEnvironment(): VariableScope;
+    endLexicalEnvironment(): Node[];
+    /** Adds a `var` declaration to the current variable environment. */
+    addVariableDeclaration(name: Identifier): Identifier;
+    /** Adds a `let` declaration to the current lexical environment. */
+    addLexicalDeclaration(name: Identifier): Identifier;
+    addHoistedFunctionDeclaration(node: FunctionDeclaration): FunctionDeclaration;
+    addInitializationStatement(node: Node): Node;
+    /** Marks the current variable scope as visiting parameters; returns the previous flags. */
+    enterParameters(): number;
+    /** Restores the scope flags; returns whether a variable was hoisted while visiting the parameters. */
+    exitParameters(previousFlags: number): boolean;
+    /** `statements` with `declarations` from an ended environment merged in, keeping the list's range. */
+    mergeEnvironmentList(statements: NodeList, declarations: Node[]): NodeList;
+    /**
+     * 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: Node[], declarations: Node[]): Node[];
+    private spanEnd;
+    private isSpanKind;
+    isCustomPrologue(node: Node): boolean;
+}