tsc-ts 0.0.4 → 0.0.6

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

@@ -0,0 +1,453 @@
+// Lowers `using` and `await using` declarations, for targets before ESNext. The statements after
+// the first declaration run in a `try` whose `finally` disposes the resources, and in a source
+// file the declarations they need at the top level are hoisted out of it.
+import { AwaitExpression, Block, BindingPattern, ClassExpression, ExportAssignment, ExportDeclaration, ExportSpecifier, Identifier, NamedExports, NodeList, SyntaxList, TryStatement, CatchClause, VariableDeclaration, VariableDeclarationList, VariableStatement, ArrayLiteralExpression, } from '../ast.js';
+import { isPrologueDirective } from '../printer/utilities.js';
+import { convertBindingNameToTarget } from './destructuring.js';
+import { isNamedEvaluation, transformNamedEvaluation } from './named-evaluation.js';
+import { Transformer } from './transformer.js';
+import { hasSyntacticModifier, skipOuterExpressions } from './utilities.js';
+export class UsingTransformer extends Transformer {
+    facts;
+    /** `export { x }` specifiers for hoisted exports, by local name in first-export order. */
+    exportBindings;
+    exportVars;
+    defaultExportBinding;
+    exportEqualsBinding;
+    constructor(context, facts) {
+        super(context);
+        this.facts = facts;
+        this.exportBindings = new Map();
+        this.exportVars = [];
+        this.defaultExportBinding = undefined;
+        this.exportEqualsBinding = undefined;
+    }
+    visit(node) {
+        if (!this.facts.has(node, 4 /* SubtreeFacts.ContainsUsing */))
+            return node;
+        switch (node.kind) {
+            case 307 /* SyntaxKind.SourceFile */:
+                return this.visitSourceFile(node);
+            case 242 /* SyntaxKind.Block */:
+                return this.visitBlock(node);
+            case 249 /* SyntaxKind.ForStatement */:
+                return this.visitForStatement(node);
+            case 251 /* SyntaxKind.ForOfStatement */:
+                return this.visitForOfStatement(node);
+        }
+        return this.visitEachChild(node);
+    }
+    /**
+     * Hoists imports, exports, functions and the bindings of other top-level declarations out of
+     * the `try`, keeping the statements before the first `using` in place:
+     *
+     *   import { w } from "mod";      import { w } from "mod";
+     *   const x = expr1;              const x = expr1;
+     *   using y = expr2;         ->   var y, z;
+     *   const z = expr3;              const env_1 = { stack: [], error: void 0, hasError: false };
+     *                                 try { y = __addDisposableResource(env_1, expr2, false); z = expr3; } ...
+     */
+    visitSourceFile(node) {
+        if (node.isDeclarationFile)
+            return node;
+        const factory = this.factory;
+        const context = this.context;
+        let visited;
+        const statements = node.statements.nodes;
+        const usingKind = getUsingKindOfStatements(statements);
+        if (usingKind !== 0 /* UsingKind.None */) {
+            context.startVariableEnvironment();
+            this.exportBindings = new Map();
+            this.exportVars = [];
+            const prologueEnd = getPrologueEnd(statements);
+            const topLevel = [];
+            for (let i = 0; i < prologueEnd; i++)
+                this.pushVisited(statements[i], topLevel);
+            let start = prologueEnd;
+            while (start < statements.length && getUsingKind(statements[start]) === 0 /* UsingKind.None */)
+                start++;
+            if (start >= statements.length)
+                throw new Error("Should have encountered at least one 'using' statement.");
+            for (let i = prologueEnd; i < start; i++)
+                this.pushVisited(statements[i], topLevel);
+            const env = this.createEnvBinding();
+            const body = this.transformUsingDeclarations(statements.slice(start), env, topLevel);
+            if (this.exportBindings.size > 0) {
+                const specifiers = [];
+                for (const specifier of this.exportBindings.values())
+                    specifiers.push(specifier);
+                topLevel.push(factory.created(new ExportDeclaration(undefined, false, factory.created(new NamedExports(factory.createNodeList(specifiers))), undefined, undefined)));
+            }
+            const hoisted = context.endVariableEnvironment();
+            for (let i = 0; i < hoisted.length; i++)
+                topLevel.push(hoisted[i]);
+            if (this.exportVars.length > 0)
+                topLevel.push(factory.createVariableStatement(factory.createModifierList([factory.createToken(94 /* SyntaxKind.ExportKeyword */)]), factory.createVariableDeclarationList(factory.createNodeList(this.exportVars), 1 /* NodeFlags.Let */)));
+            const lowered = this.createDownlevelUsingStatements(body, env, usingKind === 2 /* UsingKind.Async */);
+            for (let i = 0; i < lowered.length; i++)
+                topLevel.push(lowered[i]);
+            if (this.exportEqualsBinding !== undefined)
+                topLevel.push(factory.created(new ExportAssignment(undefined, true, undefined, this.exportEqualsBinding)));
+            visited = factory.updateSourceFile(node, factory.createNodeList(topLevel), node.endOfFileToken);
+        }
+        else
+            visited = this.visitEachChild(node);
+        const helpers = context.readEmitHelpers();
+        for (let i = 0; i < helpers.length; i++)
+            context.addEmitHelper(visited, helpers[i]);
+        this.exportVars = [];
+        this.exportBindings = new Map();
+        this.defaultExportBinding = undefined;
+        this.exportEqualsBinding = undefined;
+        return visited;
+    }
+    pushVisited(statement, statements) {
+        const visited = this.visit(statement);
+        if (visited instanceof SyntaxList)
+            for (let i = 0; i < visited.children.length; i++)
+                statements.push(visited.children[i]);
+        else if (visited !== undefined)
+            statements.push(visited);
+        return true;
+    }
+    visitBlock(node) {
+        const statements = node.statements.nodes;
+        const usingKind = getUsingKindOfStatements(statements);
+        if (usingKind === 0 /* UsingKind.None */)
+            return this.visitEachChild(node);
+        const prologueEnd = getPrologueEnd(statements);
+        const env = this.createEnvBinding();
+        const result = [];
+        for (let i = 0; i < prologueEnd; i++)
+            this.pushVisited(statements[i], result);
+        const lowered = this.createDownlevelUsingStatements(this.transformUsingDeclarations(statements.slice(prologueEnd), env, undefined), env, usingKind === 2 /* UsingKind.Async */);
+        for (let i = 0; i < lowered.length; i++)
+            result.push(lowered[i]);
+        return this.factory.updateBlock(node, new NodeList(node.statements.pos, node.statements.end, result), node.multiLine);
+    }
+    /** `for (using x = e; c; i) s` -> `{ using x = e; for (; c; i) s }`, then lowered. */
+    visitForStatement(node) {
+        const initializer = node.initializer;
+        if (initializer === undefined || !isUsingVariableDeclarationList(initializer))
+            return this.visitEachChild(node);
+        const factory = this.factory;
+        return this.visitNode(factory.createBlock([
+            factory.createVariableStatement(undefined, initializer),
+            factory.updateForStatement(node, undefined, node.condition, node.incrementor, node.statement),
+        ], false));
+    }
+    /** `for (using x of y) s` -> `for (const x_1 of y) { using x = x_1; s }`, then lowered. */
+    visitForOfStatement(node) {
+        if (!isUsingVariableDeclarationList(node.initializer))
+            return this.visitEachChild(node);
+        const factory = this.factory;
+        const list = node.initializer;
+        const declarations = list.declarations.nodes;
+        const declaration = declarations.length > 0
+            ? declarations[0]
+            : factory.createVariableDeclaration(factory.createTempVariable(0), undefined, undefined, undefined);
+        const isAwaitUsing = getUsingKindOfVariableDeclarationList(list) === 2 /* UsingKind.Async */;
+        const temp = factory.createGeneratedNameForNode(declaration.name, 0, '', '');
+        const usingStatement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList([
+            factory.updateVariableDeclaration(declaration, declaration.name, undefined, undefined, temp),
+        ]), isAwaitUsing ? 6 /* NodeFlags.AwaitUsing */ : 4 /* NodeFlags.Using */));
+        let statement;
+        const body = node.statement;
+        if (body instanceof Block) {
+            const statements = [usingStatement];
+            for (let i = 0; i < body.statements.nodes.length; i++)
+                statements.push(body.statements.nodes[i]);
+            statement = factory.updateBlock(body, factory.createNodeList(statements), body.multiLine);
+        }
+        else
+            statement = factory.createBlock([usingStatement, body], true);
+        return this.visitNode(factory.updateForInOrOfStatement(node, node.awaitModifier, factory.createVariableDeclarationList(factory.createNodeList([factory.createVariableDeclaration(temp, undefined, undefined, undefined)]), 2 /* NodeFlags.Const */), node.expression, statement));
+    }
+    /** The statements with each `using` declaration's values passed to `__addDisposableResource`. */
+    transformUsingDeclarations(statements, env, topLevel) {
+        const factory = this.factory;
+        const result = [];
+        for (let i = 0; i < statements.length; i++) {
+            const statement = statements[i];
+            const usingKind = getUsingKind(statement);
+            if (usingKind !== 0 /* UsingKind.None */) {
+                const variableStatement = statement;
+                const list = variableStatement.declarationList;
+                let declarations = [];
+                const nodes = list.declarations.nodes;
+                for (let j = 0; j < nodes.length; j++) {
+                    let declaration = nodes[j];
+                    // Binding patterns are a grammar error: leave the statement as it is.
+                    if (!(declaration.name instanceof Identifier)) {
+                        declarations = [];
+                        break;
+                    }
+                    if (isNamedEvaluation(this.context, declaration, undefined))
+                        declaration = transformNamedEvaluation(this.context, declaration, false, '');
+                    let initializer = this.visitNode(declaration.initializer);
+                    if (initializer === undefined)
+                        initializer = factory.createVoidZero();
+                    declarations.push(factory.updateVariableDeclaration(declaration, declaration.name, undefined, undefined, factory.createAddDisposableResourceHelper(env, initializer, usingKind === 2 /* UsingKind.Async */)));
+                }
+                if (declarations.length > 0) {
+                    const updatedList = factory.createVariableDeclarationList(factory.createNodeList(declarations), 2 /* NodeFlags.Const */);
+                    this.context.setOriginal(updatedList, list);
+                    updatedList.pos = list.pos;
+                    updatedList.end = list.end;
+                    this.hoistOrAppend(factory.updateVariableStatement(variableStatement, undefined, updatedList), result, topLevel);
+                    continue;
+                }
+            }
+            const visited = this.visit(statement);
+            if (visited instanceof SyntaxList)
+                for (let j = 0; j < visited.children.length; j++)
+                    this.hoistOrAppend(visited.children[j], result, topLevel);
+            else if (visited !== undefined)
+                this.hoistOrAppend(visited, result, topLevel);
+        }
+        return result;
+    }
+    hoistOrAppend(node, statements, topLevel) {
+        const hoisted = this.hoist(node, topLevel);
+        if (hoisted !== undefined)
+            statements.push(hoisted);
+        return true;
+    }
+    /** What stays in the `try` of a visited top-level statement, once its bindings are hoisted. */
+    hoist(node, topLevel) {
+        if (topLevel === undefined)
+            return node;
+        switch (node.kind) {
+            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 263 /* SyntaxKind.FunctionDeclaration */:
+                topLevel.push(node);
+                return undefined;
+            case 278 /* SyntaxKind.ExportAssignment */:
+                return this.hoistExportAssignment(node);
+            case 264 /* SyntaxKind.ClassDeclaration */:
+                return this.hoistClassDeclaration(node);
+            case 244 /* SyntaxKind.VariableStatement */:
+                return this.hoistVariableStatement(node);
+        }
+        return node;
+    }
+    createDefaultBinding() {
+        return this.factory.createUniqueName('_default', 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */ |
+            32 /* GeneratedIdentifierFlags.FileLevel */ |
+            16 /* GeneratedIdentifierFlags.Optimistic */);
+    }
+    hoistExportAssignment(node) {
+        const factory = this.factory;
+        if (node.isExportEquals) {
+            // export = expr; -> var _default; try { _default = expr; } ... export = _default;
+            if (this.exportEqualsBinding !== undefined)
+                return node;
+            const binding = this.createDefaultBinding();
+            this.exportEqualsBinding = binding;
+            this.context.addVariableDeclaration(binding);
+            return factory.createExpressionStatement(factory.createAssignment(binding, node.expression));
+        }
+        // export default expr; -> var _default; export { _default as default }; try { _default = expr; } ...
+        if (this.defaultExportBinding !== undefined)
+            return node;
+        const binding = this.createDefaultBinding();
+        this.defaultExportBinding = binding;
+        this.hoistBindingIdentifier(binding, true, factory.createIdentifier('default'), node);
+        // Give an anonymous class or function the name `default`.
+        let expression = node.expression;
+        const inner = skipOuterExpressions(expression, 63 /* OuterExpressionKinds.All */);
+        if (isNamedEvaluation(this.context, inner, undefined))
+            expression = factory.restoreOuterExpressions(expression, transformNamedEvaluation(this.context, inner, false, 'default'), 63 /* OuterExpressionKinds.All */);
+        return factory.createExpressionStatement(factory.createAssignment(binding, expression));
+    }
+    /** `class C {}` -> `C = class C {}` in the `try`, with `C` hoisted (and exported if it was). */
+    hoistClassDeclaration(node) {
+        const factory = this.factory;
+        const context = this.context;
+        if (node.name === undefined && this.defaultExportBinding !== undefined)
+            return node;
+        const isExported = hasSyntacticModifier(node, 32 /* ModifierFlags.Export */);
+        const isDefault = hasSyntacticModifier(node, 2048 /* ModifierFlags.Default */);
+        let expression = this.convertClassDeclarationToClassExpression(node);
+        if (node.name !== undefined) {
+            this.hoistBindingIdentifier(factory.getLocalName(node, 0 /* NameOptions.None */), isExported && !isDefault, undefined, node);
+            expression = factory.createAssignment(factory.getDeclarationName(node, 0 /* NameOptions.None */), expression);
+            context.setOriginal(expression, node);
+            context.setSourceMapRange(expression, node.pos, node.end);
+            context.setCommentRange(expression, node.pos, node.end);
+            if (isNamedEvaluation(context, expression, undefined))
+                expression = transformNamedEvaluation(context, expression, false, '');
+        }
+        if (isDefault && this.defaultExportBinding === undefined) {
+            // export default class C {} -> _default = C = class C {}, exported as `default`.
+            const binding = this.createDefaultBinding();
+            this.defaultExportBinding = binding;
+            this.hoistBindingIdentifier(binding, true, factory.createIdentifier('default'), node);
+            expression = factory.createAssignment(binding, expression);
+            context.setOriginal(expression, node);
+            if (isNamedEvaluation(context, expression, undefined))
+                expression = transformNamedEvaluation(context, expression, false, 'default');
+        }
+        return factory.createExpressionStatement(expression);
+    }
+    convertClassDeclarationToClassExpression(node) {
+        const updated = this.factory.created(new ClassExpression(this.extractModifiers(node.modifiers, ~2080 /* ModifierFlags.ExportDefault */), node.name, node.typeParameters, node.heritageClauses, node.members));
+        this.context.setOriginal(updated, node);
+        updated.pos = node.pos;
+        updated.end = node.end;
+        return updated;
+    }
+    hoistVariableStatement(node) {
+        const factory = this.factory;
+        const context = this.context;
+        const expressions = [];
+        const isExported = hasSyntacticModifier(node, 32 /* ModifierFlags.Export */);
+        const declarations = node.declarationList.declarations.nodes;
+        for (let i = 0; i < declarations.length; i++) {
+            const variable = declarations[i];
+            this.hoistBindingElement(variable, isExported, variable);
+            if (variable.initializer !== undefined)
+                expressions.push(this.hoistInitializedVariable(variable));
+        }
+        if (expressions.length === 0)
+            return undefined;
+        const statement = factory.createExpressionStatement(factory.inlineExpressions(expressions));
+        context.setOriginal(statement, node);
+        context.setCommentRange(statement, node.pos, node.end);
+        context.setSourceMapRange(statement, node.pos, node.end);
+        return statement;
+    }
+    hoistInitializedVariable(node) {
+        const factory = this.factory;
+        const context = this.context;
+        let target;
+        if (node.name instanceof Identifier) {
+            target = factory.cloneIdentifier(node.name);
+            context.setEmitFlags(target, context.getEmitFlags(target) & ~(4096 /* EmitFlags.LocalName */ | 2048 /* EmitFlags.ExportName */));
+        }
+        else
+            target = convertBindingNameToTarget(this, node.name);
+        const assignment = factory.createAssignment(target, node.initializer);
+        context.setOriginal(assignment, node);
+        context.setCommentRange(assignment, node.pos, node.end);
+        context.setSourceMapRange(assignment, node.pos, node.end);
+        return assignment;
+    }
+    hoistBindingElement(node, isExported, original) {
+        const name = getBindingName(node);
+        if (name instanceof BindingPattern) {
+            const elements = name.elements.nodes;
+            for (let i = 0; i < elements.length; i++)
+                if (getBindingName(elements[i]) !== undefined)
+                    this.hoistBindingElement(elements[i], isExported, original);
+        }
+        else if (name instanceof Identifier)
+            this.hoistBindingIdentifier(name, isExported, undefined, original);
+        return true;
+    }
+    hoistBindingIdentifier(node, isExport, exportAlias, original) {
+        const factory = this.factory;
+        const context = this.context;
+        const name = context.hasAutoGenerateInfo(node) ? node : factory.cloneIdentifier(node);
+        if (isExport) {
+            if (exportAlias === undefined && (context.getEmitFlags(name) & 4096 /* EmitFlags.LocalName */) === 0) {
+                const declaration = factory.createVariableDeclaration(name, undefined, undefined, undefined);
+                if (original !== undefined)
+                    context.setOriginal(declaration, original);
+                this.exportVars.push(declaration);
+                return true;
+            }
+            const specifier = exportAlias !== undefined
+                ? factory.created(new ExportSpecifier(false, name, exportAlias))
+                : factory.created(new ExportSpecifier(false, undefined, name));
+            if (original !== undefined)
+                context.setOriginal(specifier, original);
+            this.exportBindings.set(name.text, specifier);
+        }
+        context.addVariableDeclaration(name);
+        return true;
+    }
+    createEnvBinding() {
+        return this.factory.createUniqueName('env', 0);
+    }
+    /**
+     *   const env_1 = { stack: [], error: void 0, hasError: false };
+     *   try { body }
+     *   catch (e_1) { env_1.error = e_1; env_1.hasError = true; }
+     *   finally { __disposeResources(env_1); }
+     *
+     * With `async`, the `finally` awaits the result: `const result_1 = __disposeResources(env_1); if (result_1) await result_1;`.
+     * Two properties record the error since `throw undefined` is legal.
+     */
+    createDownlevelUsingStatements(body, env, async) {
+        const factory = this.factory;
+        const envObject = factory.createObjectLiteral([
+            factory.createPropertyAssignment(factory.createIdentifier('stack'), factory.created(new ArrayLiteralExpression(factory.createNodeList([]), false))),
+            factory.createPropertyAssignment(factory.createIdentifier('error'), factory.createVoidZero()),
+            factory.createPropertyAssignment(factory.createIdentifier('hasError'), factory.createKeywordExpression(96 /* SyntaxKind.FalseKeyword */)),
+        ], false);
+        const envStatement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList([factory.createVariableDeclaration(env, undefined, undefined, envObject)]), 2 /* NodeFlags.Const */));
+        const tryBlock = factory.createBlock(body, true);
+        const error = factory.createUniqueName('e', 0);
+        const catchClause = factory.created(new CatchClause(factory.createVariableDeclaration(error, undefined, undefined, undefined), factory.createBlock([
+            factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(env, factory.createIdentifier('error')), error)),
+            factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(env, factory.createIdentifier('hasError')), factory.createTrue())),
+        ], true)));
+        let finallyBlock;
+        if (async) {
+            const result = factory.createUniqueName('result', 0);
+            finallyBlock = factory.createBlock([
+                factory.createVariableStatement(undefined, factory.createVariableDeclarationList(factory.createNodeList([
+                    factory.createVariableDeclaration(result, undefined, undefined, factory.createDisposeResourcesHelper(env)),
+                ]), 2 /* NodeFlags.Const */)),
+                factory.createIfStatement(result, factory.createExpressionStatement(factory.created(new AwaitExpression(result))), undefined),
+            ], true);
+        }
+        else
+            finallyBlock = factory.createBlock([factory.createExpressionStatement(factory.createDisposeResourcesHelper(env))], true);
+        return [envStatement, factory.created(new TryStatement(tryBlock, catchClause, finallyBlock))];
+    }
+}
+function getPrologueEnd(statements) {
+    let i = 0;
+    while (i < statements.length && isPrologueDirective(statements[i]))
+        i++;
+    return i;
+}
+function getUsingKindOfVariableDeclarationList(node) {
+    const flags = node.flags & 7 /* NodeFlags.BlockScoped */;
+    if (flags === 6 /* NodeFlags.AwaitUsing */)
+        return 2 /* UsingKind.Async */;
+    if (flags === 4 /* NodeFlags.Using */)
+        return 1 /* UsingKind.Sync */;
+    return 0 /* UsingKind.None */;
+}
+function isUsingVariableDeclarationList(node) {
+    return (node instanceof VariableDeclarationList &&
+        getUsingKindOfVariableDeclarationList(node) !== 0 /* UsingKind.None */);
+}
+function getUsingKind(statement) {
+    if (!(statement instanceof VariableStatement))
+        return 0 /* UsingKind.None */;
+    return getUsingKindOfVariableDeclarationList(statement.declarationList);
+}
+function getUsingKindOfStatements(statements) {
+    let result = 0 /* UsingKind.None */;
+    for (let i = 0; i < statements.length; i++) {
+        const kind = getUsingKind(statements[i]);
+        if (kind === 2 /* UsingKind.Async */)
+            return 2 /* UsingKind.Async */;
+        if (kind > result)
+            result = kind;
+    }
+    return result;
+}
+function getBindingName(node) {
+    if (node instanceof VariableDeclaration)
+        return node.name;
+    if (node.kind === 209 /* SyntaxKind.BindingElement */)
+        return node.name;
+    return undefined;
+}

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

@@ -0,0 +1,50 @@
+import { ModifierFlags, ModuleDeclaration, type Node, SourceFile, LabeledStatement } from '../ast.js';
+import type { NodeFactory } from '../printer/factory.js';
+export declare function modifierFlagsOf(node: Node): ModifierFlags;
+export declare function hasSyntacticModifier(node: Node, flags: ModifierFlags): boolean;
+export declare function hasDecorators(node: Node): boolean;
+export declare function isThisParameter(node: Node): boolean;
+export declare function isParameterPropertyDeclaration(node: Node, parent: Node | undefined): boolean;
+/** `/** @type {T} *\/ (expr)` in a JavaScript file. */
+export declare function isJSDocTypeAssertion(node: Node): boolean;
+export declare function isExternalModule(file: SourceFile): boolean;
+export declare function getInnermostModuleDeclaration(node: ModuleDeclaration): ModuleDeclaration;
+export declare const enum ModuleInstanceState {
+    Unknown = 0,
+    NonInstantiated = 1,
+    Instantiated = 2,
+    ConstEnumOnly = 3
+}
+/** Whether a namespace has runtime content, from its syntax alone. */
+export declare function getModuleInstanceState(node: ModuleDeclaration): ModuleInstanceState;
+export declare function isInstantiatedModule(node: ModuleDeclaration, preserveConstEnums: boolean): boolean;
+/** Whether `name` is used as a value in `parent`, rather than declared or as a property name. */
+export declare function isIdentifierReference(name: Node, parent: Node | undefined): boolean;
+/** The node itself for one node, else a syntax list of them; undefined for none. */
+export declare function singleOrMany(nodes: Node[], factory: NodeFactory): Node | undefined;
+/** Whether two optional nodes are the same node. */
+export declare function isSameNode(a: Node | undefined, b: Node | undefined): boolean;
+/** The statement binding a `for...of` head to `boundValue`: a declaration or an assignment. */
+export declare function createForOfBindingStatement(factory: NodeFactory, node: Node, boundValue: Node): Node;
+/** `node` wrapped in the labels of `outermost` and the labeled statements nested in it. */
+export declare function restoreEnclosingLabel(factory: NodeFactory, node: Node, outermost: LabeledStatement | undefined): Node;
+/** Kinds of expressions wrapping another that `skipOuterExpressions` looks through. */
+export declare const enum OuterExpressionKinds {
+    None = 0,
+    Parentheses = 1,
+    TypeAssertions = 2,
+    NonNullAssertions = 4,
+    PartiallyEmittedExpressions = 8,
+    ExpressionsWithTypeArguments = 16,
+    Satisfies = 32,
+    ExcludeJSDocTypeAssertion = 64,
+    Assignments = 128,
+    Comma = 256,
+    Assertions = 38,
+    All = 63
+}
+export declare function isOuterExpression(node: Node, kinds: OuterExpressionKinds): boolean;
+/** The expression wrapped by `node`, past the outer expressions of `kinds`. */
+export declare function skipOuterExpressions(node: Node, kinds: OuterExpressionKinds): Node;
+/** The operand of an outer expression. */
+export declare function outerExpressionOperand(node: Node): Node;