tsc-ts 0.0.4 → 0.0.5

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

@@ -0,0 +1,626 @@
+// Flattens destructuring into assignments or declarations of each target: for exported names
+// that must be assigned through `exports.x` or `ns.x`, and for lowering object rest elements.
+import { ArrayLiteralExpression, BinaryExpression, BindingElement, BindingPattern, ComputedPropertyName, ElementAccessExpression, Identifier, NumericLiteral, ObjectLiteralExpression, OmittedExpression, ParameterDeclaration, PropertyAssignment, ShorthandPropertyAssignment, SpreadAssignment, SpreadElement, StringLiteral, VariableDeclaration, getName, NoSubstitutionTemplateLiteral, BigIntLiteral, } from '../ast.js';
+import { isAssignmentExpression, isDestructuringAssignment, isPropertyNameLiteral } from '../binder-utilities.js';
+import { restHelper } from '../printer/helpers.js';
+import { nodeIsSynthesized } from '../printer/utilities.js';
+/** Creates the assignment of a flattened value to an identifier, such as `exports.x = value`. */
+export class AssignmentFactory {
+}
+/** Flattens `node`, a destructuring assignment or variable declaration, into a comma expression. */
+export function flattenDestructuringAssignment(visitor, node, needsValue, assignments) {
+    const flattener = new Flattener(visitor, undefined, false, true);
+    flattener.assignments = assignments;
+    return flattener.flattenAssignment(node, needsValue);
+}
+/** Flattens a destructuring assignment only as far as needed to lower its object rest elements. */
+export function flattenObjectRestAssignment(visitor, facts, node, needsValue) {
+    return new Flattener(visitor, facts, false, true).flattenAssignment(node, needsValue);
+}
+/**
+ * Flattens the binding pattern of a variable declaration, parameter or binding element into
+ * variable declarations: a `VariableDeclaration`, a `SyntaxList` of them, or undefined. With
+ * `facts`, patterns are only decomposed as far as needed to lower object rest elements.
+ */
+export function flattenDestructuringBinding(visitor, facts, node, rval, hoistTempVariables, skipInitializer) {
+    return new Flattener(visitor, facts, true, hoistTempVariables).flattenBinding(node, rval, skipInitializer);
+}
+/** A declaration waiting for the expressions before it to be inlined into its value. */
+class PendingDeclaration {
+    pendingExpressions;
+    name;
+    value;
+    pos;
+    end;
+    original;
+    constructor(name, value, pos, end, original) {
+        this.pendingExpressions = [];
+        this.name = name;
+        this.value = value;
+        this.pos = pos;
+        this.end = end;
+        this.original = original;
+    }
+}
+class Flattener {
+    visitor;
+    /** Set to flatten only patterns with object rest elements. */
+    facts;
+    /** Emits variable declarations rather than assignments. */
+    binding;
+    hoistTempVariables;
+    assignments;
+    expressions;
+    declarations;
+    hasTransformedPriorElement;
+    constructor(visitor, facts, binding, hoistTempVariables) {
+        this.visitor = visitor;
+        this.facts = facts;
+        this.binding = binding;
+        this.hoistTempVariables = hoistTempVariables;
+        this.assignments = undefined;
+        this.expressions = [];
+        this.declarations = [];
+        this.hasTransformedPriorElement = false;
+    }
+    flattenAssignment(start, needsValue) {
+        const factory = this.visitor.factory;
+        let node = start;
+        let pos = node.pos;
+        let end = node.end;
+        let value = undefined;
+        if (node instanceof BinaryExpression && isDestructuringAssignment(node)) {
+            let assignment = node;
+            value = assignment.right;
+            while (isEmptyPattern(assignment.left)) {
+                const right = assignment.right;
+                if (right instanceof BinaryExpression && isDestructuringAssignment(right)) {
+                    assignment = right;
+                    node = right;
+                    pos = right.pos;
+                    end = right.end;
+                    value = right.right;
+                }
+                else
+                    return this.visitor.visitNode(right);
+            }
+        }
+        if (value !== undefined) {
+            value = this.visitor.visitNode(value);
+            if ((value instanceof Identifier && elementAssignsToName(node, value.text)) ||
+                elementContainsNonLiteralComputedName(node))
+                value = this.ensureIdentifier(value, false, pos, end);
+            else if (needsValue)
+                value = this.ensureIdentifier(value, true, pos, end);
+            else if (nodeIsSynthesized(node)) {
+                pos = value.pos;
+                end = value.end;
+            }
+        }
+        this.flattenElement(node, value, pos, end, node instanceof BinaryExpression && isDestructuringAssignment(node));
+        if (value !== undefined && needsValue) {
+            if (this.expressions.length === 0)
+                return value;
+            this.expressions.push(value);
+        }
+        const result = factory.inlineExpressions(this.expressions);
+        return result !== undefined ? result : factory.created(new OmittedExpression());
+    }
+    flattenBinding(start, rval, skipInitializer) {
+        const factory = this.visitor.factory;
+        let node = start;
+        if (node instanceof VariableDeclaration) {
+            let initializer = node.initializer;
+            if (initializer !== undefined &&
+                ((initializer instanceof Identifier && elementAssignsToName(node, initializer.text)) ||
+                    elementContainsNonLiteralComputedName(node))) {
+                initializer = this.ensureIdentifier(this.visitor.visitNode(initializer), false, initializer.pos, initializer.end);
+                node = factory.updateVariableDeclaration(node, node.name, undefined, undefined, initializer);
+            }
+        }
+        this.flattenElement(node, rval, node.pos, node.end, skipInitializer);
+        if (this.expressions.length > 0) {
+            const temp = factory.createTempVariable(0);
+            if (this.hoistTempVariables) {
+                const value = factory.inlineExpressions(this.expressions);
+                this.expressions = [];
+                this.emitBinding(temp, value, -1, -1, undefined);
+            }
+            else {
+                this.visitor.context.addVariableDeclaration(temp);
+                const last = this.declarations[this.declarations.length - 1];
+                last.pendingExpressions.push(factory.createAssignment(temp, last.value));
+                for (let i = 0; i < this.expressions.length; i++)
+                    last.pendingExpressions.push(this.expressions[i]);
+                last.value = temp;
+            }
+        }
+        const declarations = [];
+        for (let i = 0; i < this.declarations.length; i++) {
+            const pending = this.declarations[i];
+            let value = pending.value;
+            if (pending.pendingExpressions.length > 0) {
+                pending.pendingExpressions.push(pending.value);
+                value = factory.inlineExpressions(pending.pendingExpressions);
+            }
+            const declaration = factory.createVariableDeclaration(pending.name, undefined, undefined, value);
+            declaration.pos = pending.pos | 0;
+            declaration.end = pending.end | 0;
+            if (pending.original !== undefined)
+                this.visitor.context.setOriginal(declaration, pending.original);
+            declarations.push(declaration);
+        }
+        if (declarations.length === 0)
+            return undefined;
+        if (declarations.length === 1)
+            return declarations[0];
+        return factory.createSyntaxList(declarations);
+    }
+    emitBindingOrAssignment(target, value, pos, end, original) {
+        if (this.binding)
+            return this.emitBinding(target, value, pos, end, original);
+        return this.emitAssignment(target, value, pos, end, original);
+    }
+    emitAssignment(target, value, pos, end, original) {
+        let expression;
+        if (this.assignments !== undefined && target instanceof Identifier)
+            expression = this.assignments.createAssignment(target, value, pos, end);
+        else {
+            expression = this.visitor.factory.createAssignment(this.visitor.visitNode(target), value);
+            expression.pos = pos | 0;
+            expression.end = end | 0;
+        }
+        if (original !== undefined)
+            this.visitor.context.setOriginal(expression, original);
+        this.expressions.push(expression);
+        return true;
+    }
+    emitBinding(target, start, pos, end, original) {
+        let value = start;
+        if (this.expressions.length > 0) {
+            this.expressions.push(value);
+            value = this.visitor.factory.inlineExpressions(this.expressions);
+            this.expressions = [];
+        }
+        this.declarations.push(new PendingDeclaration(target, value, pos, end, original));
+        return true;
+    }
+    createPattern(object, elements) {
+        const factory = this.visitor.factory;
+        const list = factory.createNodeList(elements);
+        if (this.binding)
+            return factory.created(new BindingPattern(object ? 207 /* SyntaxKind.ObjectBindingPattern */ : 208 /* SyntaxKind.ArrayBindingPattern */, list));
+        if (object)
+            return factory.created(new ObjectLiteralExpression(list, false));
+        return factory.created(new ArrayLiteralExpression(list, false));
+    }
+    createArrayElement(expression) {
+        if (!this.binding)
+            return expression;
+        return this.visitor.factory.created(new BindingElement(undefined, undefined, expression, undefined));
+    }
+    ensureIdentifier(value, reuseIdentifierExpressions, pos, end) {
+        if (reuseIdentifierExpressions && value instanceof Identifier)
+            return value;
+        const factory = this.visitor.factory;
+        const temp = factory.createTempVariable(0);
+        if (this.hoistTempVariables) {
+            this.visitor.context.addVariableDeclaration(temp);
+            const assignment = factory.createAssignment(temp, value);
+            assignment.pos = pos | 0;
+            assignment.end = end | 0;
+            this.expressions.push(assignment);
+        }
+        else
+            this.emitBindingOrAssignment(temp, value, pos, end, undefined);
+        return temp;
+    }
+    createDefaultValueCheck(value, defaultValue, pos, end) {
+        const checked = this.ensureIdentifier(value, true, pos, end);
+        const factory = this.visitor.factory;
+        return factory.createConditionalExpression(factory.createTypeCheck(checked, 'undefined'), defaultValue, checked);
+    }
+    createPropertyAccess(value, propertyName) {
+        const factory = this.visitor.factory;
+        if (propertyName instanceof ComputedPropertyName) {
+            const argument = this.ensureIdentifier(this.visitor.visitNode(propertyName.expression), false, propertyName.pos, propertyName.end);
+            return factory.createElementAccessExpression(value, argument);
+        }
+        if (propertyName instanceof StringLiteral)
+            return factory.createElementAccessExpression(value, factory.createStringLiteral(propertyName.text, propertyName.tokenFlags));
+        if (propertyName instanceof NoSubstitutionTemplateLiteral)
+            return factory.createElementAccessExpression(value, factory.createStringLiteral(propertyName.text, 0 /* TokenFlags.None */));
+        if (propertyName instanceof NumericLiteral)
+            return factory.createElementAccessExpression(value, factory.createNumericLiteral(propertyName.text));
+        if (propertyName instanceof BigIntLiteral)
+            return factory.createElementAccessExpression(value, factory.created(new BigIntLiteral(propertyName.text, 0 /* TokenFlags.None */)));
+        return factory.createPropertyAccessExpression(value, factory.createIdentifier(propertyNameText(propertyName)));
+    }
+    flattenElement(element, start, pos, end, skipInitializer) {
+        const target = getTargetOfBindingOrAssignmentElement(element);
+        if (target === undefined)
+            return false;
+        let value = start;
+        if (!skipInitializer) {
+            const initializer = this.visitor.visitNode(getInitializerOfBindingOrAssignmentElement(element));
+            if (initializer !== undefined) {
+                if (value !== undefined) {
+                    value = this.createDefaultValueCheck(value, initializer, pos, end);
+                    if (!isSimpleCopiableExpression(initializer) && isPattern(target))
+                        value = this.ensureIdentifier(value, true, pos, end);
+                }
+                else
+                    value = initializer;
+            }
+            else if (value === undefined)
+                value = this.visitor.factory.createVoidZero();
+        }
+        if (target instanceof ObjectLiteralExpression || target.kind === 207 /* SyntaxKind.ObjectBindingPattern */)
+            return this.flattenObjectPattern(element, target, value, pos, end);
+        if (target instanceof ArrayLiteralExpression || target.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+            return this.flattenArrayPattern(element, target, value, pos, end);
+        return this.emitBindingOrAssignment(target, value, pos, end, element);
+    }
+    flattenObjectPattern(parent, pattern, start, pos, end) {
+        const elements = getElementsOfBindingOrAssignmentPattern(pattern);
+        const facts = this.facts;
+        let value = start;
+        if (elements.length !== 1)
+            value = this.ensureIdentifier(value, !isDeclarationBindingElement(parent) || elements.length !== 0, pos, end);
+        let bindingElements = [];
+        const computedTempVariables = [];
+        for (let i = 0; i < elements.length; i++) {
+            const element = elements[i];
+            if (getRestIndicatorOfBindingOrAssignmentElement(element) === undefined) {
+                const propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(element);
+                if (facts !== undefined &&
+                    !facts.hasRestOrSpread(element) &&
+                    !facts.hasRestOrSpread(getTargetOfBindingOrAssignmentElement(element)) &&
+                    !(propertyName instanceof ComputedPropertyName)) {
+                    bindingElements.push(this.visitor.visitNode(element));
+                    continue;
+                }
+                if (propertyName === undefined)
+                    continue;
+                if (bindingElements.length > 0) {
+                    this.emitBindingOrAssignment(this.createPattern(true, bindingElements), value, pos, end, pattern);
+                    bindingElements = [];
+                }
+                const rhs = this.createPropertyAccess(value, propertyName);
+                if (propertyName instanceof ComputedPropertyName && rhs instanceof ElementAccessExpression)
+                    computedTempVariables.push(rhs.argumentExpression);
+                this.flattenElement(element, rhs, element.pos, element.end, false);
+            }
+            else if (i === elements.length - 1) {
+                if (bindingElements.length > 0) {
+                    this.emitBindingOrAssignment(this.createPattern(true, bindingElements), value, pos, end, pattern);
+                    bindingElements = [];
+                }
+                const rhs = this.createRestHelper(value, elements, computedTempVariables, pattern.pos, pattern.end);
+                this.flattenElement(element, rhs, element.pos, element.end, false);
+            }
+        }
+        if (bindingElements.length > 0)
+            this.emitBindingOrAssignment(this.createPattern(true, bindingElements), value, pos, end, pattern);
+        return true;
+    }
+    flattenArrayPattern(parent, pattern, start, pos, end) {
+        const factory = this.visitor.factory;
+        const facts = this.facts;
+        const elements = getElementsOfBindingOrAssignmentPattern(pattern);
+        let value = start;
+        let allOmitted = true;
+        for (const element of elements)
+            if (!(element instanceof OmittedExpression))
+                allOmitted = false;
+        if ((elements.length !== 1 && (facts === undefined || elements.length === 0)) || allOmitted)
+            value = this.ensureIdentifier(value, !isDeclarationBindingElement(parent) || elements.length !== 0, pos, end);
+        const bindingElements = [];
+        // Elements bound to temporaries in the pattern, flattened after it.
+        const restTemps = [];
+        const restElements = [];
+        for (let i = 0; i < elements.length; i++) {
+            const element = elements[i];
+            if (facts !== undefined) {
+                if (facts.hasObjectRestOrSpread(element) ||
+                    (this.hasTransformedPriorElement && !isSimpleBindingOrAssignmentElement(element))) {
+                    this.hasTransformedPriorElement = true;
+                    const temp = factory.createTempVariable(0);
+                    if (this.hoistTempVariables)
+                        this.visitor.context.addVariableDeclaration(temp);
+                    restTemps.push(temp);
+                    restElements.push(element);
+                    bindingElements.push(this.createArrayElement(temp));
+                }
+                else
+                    bindingElements.push(element);
+            }
+            else if (element instanceof OmittedExpression)
+                continue;
+            else if (getRestIndicatorOfBindingOrAssignmentElement(element) === undefined) {
+                const rhs = factory.createElementAccessExpression(value, factory.createNumericLiteral(String(i)));
+                this.flattenElement(element, rhs, element.pos, element.end, false);
+            }
+            else if (i === elements.length - 1) {
+                const args = i === 0 ? [] : [factory.createNumericLiteral(String(i))];
+                const rhs = factory.createCallExpression(factory.createPropertyAccessExpression(value, factory.createIdentifier('slice')), args);
+                this.flattenElement(element, rhs, element.pos, element.end, false);
+            }
+        }
+        if (bindingElements.length > 0)
+            this.emitBindingOrAssignment(this.createPattern(false, bindingElements), value, pos, end, pattern);
+        for (let i = 0; i < restElements.length; i++) {
+            const element = restElements[i];
+            this.flattenElement(element, restTemps[i], element.pos, element.end, false);
+        }
+        return true;
+    }
+    /** `__rest(value, ["a", "b"])`, excluding the properties named before the rest element. */
+    createRestHelper(value, elements, computed, pos, end) {
+        const factory = this.visitor.factory;
+        this.visitor.context.requestEmitHelper(restHelper);
+        const names = [];
+        let computedOffset = 0;
+        for (let i = 0; i < elements.length - 1; i++) {
+            const propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(elements[i]);
+            if (propertyName === undefined)
+                continue;
+            if (propertyName instanceof ComputedPropertyName) {
+                const temp = computed[computedOffset++];
+                names.push(factory.createConditionalExpression(factory.createTypeCheck(temp, 'symbol'), temp, factory.createBinaryExpression(temp, 39 /* SyntaxKind.PlusToken */, factory.createStringLiteral('', 0 /* TokenFlags.None */))));
+            }
+            else
+                names.push(factory.createStringLiteralFromNode(propertyName));
+        }
+        const array = factory.created(new ArrayLiteralExpression(factory.createNodeList(names), false));
+        array.pos = pos | 0;
+        array.end = end | 0;
+        return factory.createCallExpression(factory.createUnscopedHelperName('__rest'), [value, array]);
+    }
+}
+function propertyNameText(node) {
+    if (node instanceof Identifier)
+        return node.text;
+    return '';
+}
+function isEmptyPattern(node) {
+    if (node instanceof ArrayLiteralExpression)
+        return node.elements.nodes.length === 0;
+    if (node instanceof ObjectLiteralExpression)
+        return node.properties.nodes.length === 0;
+    return false;
+}
+function isPattern(node) {
+    switch (node.kind) {
+        case 207 /* SyntaxKind.ObjectBindingPattern */:
+        case 208 /* SyntaxKind.ArrayBindingPattern */:
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            return true;
+    }
+    return false;
+}
+/** Strings, numbers, keywords and identifiers: copied rather than cached in a temporary. */
+export function isSimpleCopiableExpression(node) {
+    switch (node.kind) {
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 79 /* SyntaxKind.Identifier */:
+            return true;
+    }
+    return node.kind >= 82 /* SyntaxKind.FirstKeyword */ && node.kind <= 166 /* SyntaxKind.LastKeyword */;
+}
+function isDeclarationBindingElement(node) {
+    return (node.kind === 261 /* SyntaxKind.VariableDeclaration */ ||
+        node.kind === 170 /* SyntaxKind.Parameter */ ||
+        node.kind === 209 /* SyntaxKind.BindingElement */);
+}
+/** Whether an element binds identifiers to literal property names with simple defaults. */
+function isSimpleBindingOrAssignmentElement(element) {
+    const target = getTargetOfBindingOrAssignmentElement(element);
+    if (target === undefined || target instanceof OmittedExpression)
+        return true;
+    const propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(element);
+    if (propertyName !== undefined && !isPropertyNameLiteral(propertyName))
+        return false;
+    const initializer = getInitializerOfBindingOrAssignmentElement(element);
+    if (initializer !== undefined && (initializer instanceof Identifier || !isSimpleCopiableExpression(initializer)))
+        return false;
+    if (isPattern(target)) {
+        const elements = getElementsOfBindingOrAssignmentPattern(target);
+        for (const child of elements)
+            if (!isSimpleBindingOrAssignmentElement(child))
+                return false;
+        return true;
+    }
+    return target instanceof Identifier;
+}
+export function getElementsOfBindingOrAssignmentPattern(node) {
+    if (node instanceof BindingPattern)
+        return node.elements.nodes;
+    if (node instanceof ArrayLiteralExpression)
+        return node.elements.nodes;
+    if (node instanceof ObjectLiteralExpression)
+        return node.properties.nodes;
+    return [];
+}
+export function getTargetOfBindingOrAssignmentElement(element) {
+    if (isDeclarationBindingElement(element))
+        return getName(element);
+    if (element instanceof PropertyAssignment)
+        return getTargetOfBindingOrAssignmentElement(element.initializer);
+    if (element instanceof ShorthandPropertyAssignment)
+        return element.name;
+    if (element instanceof SpreadAssignment)
+        return getTargetOfBindingOrAssignmentElement(element.expression);
+    if (element.kind === 175 /* SyntaxKind.MethodDeclaration */ || element.kind === 178 /* SyntaxKind.GetAccessor */)
+        return undefined;
+    if (element.kind === 179 /* SyntaxKind.SetAccessor */)
+        return undefined;
+    if (element instanceof BinaryExpression && isAssignmentExpression(element, true))
+        return getTargetOfBindingOrAssignmentElement(element.left);
+    if (element instanceof SpreadElement)
+        return getTargetOfBindingOrAssignmentElement(element.expression);
+    return element;
+}
+function getInitializerOfBindingOrAssignmentElement(element) {
+    if (element === undefined)
+        return undefined;
+    if (element instanceof VariableDeclaration)
+        return element.initializer;
+    if (element instanceof ParameterDeclaration)
+        return element.initializer;
+    if (element instanceof BindingElement)
+        return element.initializer;
+    if (element instanceof PropertyAssignment) {
+        const initializer = element.initializer;
+        return initializer instanceof BinaryExpression && isAssignmentExpression(initializer, true)
+            ? initializer.right
+            : undefined;
+    }
+    if (element instanceof ShorthandPropertyAssignment)
+        return element.objectAssignmentInitializer;
+    if (element instanceof BinaryExpression && isAssignmentExpression(element, true))
+        return element.right;
+    if (element instanceof SpreadElement)
+        return getInitializerOfBindingOrAssignmentElement(element.expression);
+    return undefined;
+}
+function getRestIndicatorOfBindingOrAssignmentElement(element) {
+    if (element instanceof ParameterDeclaration)
+        return element.dotDotDotToken;
+    if (element instanceof BindingElement)
+        return element.dotDotDotToken;
+    if (element instanceof SpreadElement || element instanceof SpreadAssignment)
+        return element;
+    return undefined;
+}
+function tryGetPropertyNameOfBindingOrAssignmentElement(element) {
+    if (element instanceof BindingElement && element.propertyName !== undefined)
+        return literalComputedName(element.propertyName);
+    if (element instanceof PropertyAssignment)
+        return literalComputedName(element.name);
+    if (element instanceof SpreadAssignment)
+        return undefined;
+    const target = getTargetOfBindingOrAssignmentElement(element);
+    return target !== undefined && isPropertyName(target) ? target : undefined;
+}
+function literalComputedName(name) {
+    if (name instanceof ComputedPropertyName && isStringOrNumericLiteralLike(name.expression))
+        return name.expression;
+    return name;
+}
+function isStringOrNumericLiteralLike(node) {
+    return (node.kind === 10 /* SyntaxKind.StringLiteral */ ||
+        node.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */ ||
+        node.kind === 8 /* SyntaxKind.NumericLiteral */);
+}
+function isPropertyName(node) {
+    switch (node.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 80 /* SyntaxKind.PrivateIdentifier */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 168 /* SyntaxKind.ComputedPropertyName */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+            return true;
+    }
+    return false;
+}
+function elementAssignsToName(element, name) {
+    const target = getTargetOfBindingOrAssignmentElement(element);
+    if (target === undefined)
+        return false;
+    if (isPattern(target)) {
+        const elements = getElementsOfBindingOrAssignmentPattern(target);
+        for (const child of elements)
+            if (elementAssignsToName(child, name))
+                return true;
+        return false;
+    }
+    return target instanceof Identifier && target.text === name;
+}
+function elementContainsNonLiteralComputedName(element) {
+    const propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(element);
+    if (propertyName instanceof ComputedPropertyName && !isLiteralKind(propertyName.expression.kind))
+        return true;
+    const target = getTargetOfBindingOrAssignmentElement(element);
+    if (target === undefined || !isPattern(target))
+        return false;
+    const elements = getElementsOfBindingOrAssignmentPattern(target);
+    for (const child of elements)
+        if (elementContainsNonLiteralComputedName(child))
+            return true;
+    return false;
+}
+function isLiteralKind(kind) {
+    return kind >= 8 /* SyntaxKind.FirstLiteralToken */ && kind <= 14 /* SyntaxKind.LastLiteralToken */;
+}
+/** `pattern = initializer` for a variable declaration, with binding patterns as assignment patterns. */
+export function convertVariableDeclarationToAssignment(visitor, node) {
+    const initializer = node.initializer;
+    if (initializer === undefined)
+        return undefined;
+    const context = visitor.context;
+    const assignment = visitor.factory.createAssignment(convertBindingNameToTarget(visitor, node.name), initializer);
+    context.setOriginal(assignment, node);
+    context.assignCommentAndSourceMapRanges(assignment, node);
+    return assignment;
+}
+/** A binding name as an assignment target, with binding patterns as assignment patterns. */
+export function convertBindingNameToTarget(visitor, name) {
+    if (!(name instanceof BindingPattern))
+        return name;
+    const factory = visitor.factory;
+    const context = visitor.context;
+    const elements = name.elements.nodes;
+    const converted = [];
+    const object = name.kind === 207 /* SyntaxKind.ObjectBindingPattern */;
+    for (const element of elements) {
+        if (element instanceof BindingElement)
+            converted.push(object
+                ? convertToObjectElement(visitor, element)
+                : convertToArrayElement(visitor, element));
+    }
+    const list = factory.createNodeList(converted);
+    list.pos = name.elements.pos;
+    list.end = name.elements.end;
+    const pattern = object
+        ? factory.created(new ObjectLiteralExpression(list, false))
+        : factory.created(new ArrayLiteralExpression(list, false));
+    context.setOriginal(pattern, name);
+    context.assignCommentAndSourceMapRanges(pattern, name);
+    return pattern;
+}
+/** A created element converted from `element`, with its original and ranges. */
+function converted(visitor, node, element) {
+    visitor.context.setOriginal(node, element);
+    visitor.context.assignCommentAndSourceMapRanges(node, element);
+    return node;
+}
+function convertToArrayElement(visitor, element) {
+    const factory = visitor.factory;
+    const name = element.name;
+    if (name === undefined)
+        return converted(visitor, factory.created(new OmittedExpression()), element);
+    if (element.dotDotDotToken !== undefined)
+        return converted(visitor, factory.created(new SpreadElement(name)), element);
+    const target = convertBindingNameToTarget(visitor, name);
+    if (element.initializer === undefined)
+        return target;
+    return converted(visitor, factory.createAssignment(target, element.initializer), element);
+}
+function convertToObjectElement(visitor, element) {
+    const factory = visitor.factory;
+    const name = element.name;
+    if (element.dotDotDotToken !== undefined)
+        return converted(visitor, factory.created(new SpreadAssignment(name)), element);
+    if (element.propertyName !== undefined) {
+        let target = convertBindingNameToTarget(visitor, name);
+        if (element.initializer !== undefined)
+            target = factory.createAssignment(target, element.initializer);
+        return converted(visitor, factory.createPropertyAssignment(element.propertyName, target), element);
+    }
+    return converted(visitor, factory.created(new ShorthandPropertyAssignment(undefined, name, undefined, undefined, element.initializer !== undefined ? factory.createToken(63 /* SyntaxKind.EqualsToken */) : undefined, element.initializer)), element);
+}

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

@@ -0,0 +1,6 @@
+import type { CompilerOptions } from '../options.js';
+import type { EmitContext } from '../printer/emit-context.js';
+import type { EmitResolver } from './emit-resolver.js';
+import type { SyntaxFacts } from './syntax-facts.js';
+import type { Transformer } from './transformer.js';
+export declare function addDownlevelTransformers(transformers: Transformer[], context: EmitContext, options: CompilerOptions, facts: SyntaxFacts, resolver: EmitResolver): void;

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

@@ -0,0 +1,45 @@
+import { ScriptTarget, getEmitScriptTarget, getUseDefineForClassFields } from '../options.js';
+import { AsyncFunctions } from './async.js';
+import { ClassFieldsTransformer } from './class-fields.js';
+import { ESDecorators, shouldTransformESDecorators } from './es-decorators.js';
+import { ExponentiationTransformer } from './exponentiation.js';
+import { AsyncIteration } from './for-await.js';
+import { LogicalAssignmentTransformer } from './logical-assignment.js';
+import { NullishCoalescingTransformer } from './nullish-coalescing.js';
+import { ObjectRestSpreadTransformer } from './object-rest-spread.js';
+import { OptionalCatchTransformer } from './optional-catch.js';
+import { OptionalChainTransformer } from './optional-chain.js';
+import { TaggedTemplateTransformer } from './tagged-template.js';
+import { UsingTransformer } from './using.js';
+export function addDownlevelTransformers(transformers, context, options, facts, resolver) {
+    const target = getEmitScriptTarget(options);
+    // ES2022 and later: `using` declarations.
+    if (target < ScriptTarget.ESNext)
+        transformers.push(new UsingTransformer(context, facts));
+    // ESNext: decorators and class fields.
+    if (shouldTransformESDecorators(options))
+        transformers.push(new ESDecorators(context, facts));
+    if (!(target >= ScriptTarget.ESNext && getUseDefineForClassFields(options)))
+        transformers.push(new ClassFieldsTransformer(context, options, facts, resolver));
+    if (target >= ScriptTarget.ES2021)
+        return;
+    transformers.push(new LogicalAssignmentTransformer(context, facts));
+    if (target >= ScriptTarget.ES2020)
+        return;
+    transformers.push(new NullishCoalescingTransformer(context, facts));
+    transformers.push(new OptionalChainTransformer(context, facts));
+    if (target >= ScriptTarget.ES2019)
+        return;
+    transformers.push(new OptionalCatchTransformer(context, facts));
+    if (target >= ScriptTarget.ES2018)
+        return;
+    transformers.push(new ObjectRestSpreadTransformer(context, facts));
+    transformers.push(new AsyncIteration(context, facts));
+    transformers.push(new TaggedTemplateTransformer(context, facts));
+    if (target >= ScriptTarget.ES2017)
+        return;
+    transformers.push(new AsyncFunctions(context, facts));
+    if (target >= ScriptTarget.ES2016)
+        return;
+    transformers.push(new ExponentiationTransformer(context, facts));
+}