@tslite/parser 1.10.0 → 1.12.0

package/dist/factory.js

@@ -0,0 +1,622 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/factory.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, compareValues, createArrayLiteral, createAssignment, createBlock, createLiteral, createNodeArray, createObjectLiteral, createParen, createParenthesizedType, createPropertyAccess, createPropertyAssignment, createReturn, createShorthandPropertyAssignment, createSpread, createSpreadAssignment, createStatement, getCommentRange, getExpressionAssociativity, getExpressionPrecedence, getMutableClone, getOperatorAssociativity, getOperatorPrecedence, getSourceMapRange, getSyntheticLeadingComments, getSyntheticTrailingComments, isArrayBindingPattern, isArrayLiteralExpression, isAssignmentExpression, isBinaryExpression, isBindingElement, isBindingPattern, isBlock, isCallExpression, isDeclarationBindingElement, isExpression, isFunctionTypeNode, isIdentifier, isLeftHandSideExpression, isLiteralKind, isObjectBindingPattern, isObjectLiteralElementLike, isObjectLiteralExpression, isPrologueDirective, isPropertyAssignment, isQualifiedName, isShorthandPropertyAssignment, isSpreadElement, isStringLiteral, isUnaryExpression, map, nodeIsSynthesized, noop, notImplemented, returnUndefined, sameMap, setOriginalNode, setStartsOnNewLine, setTextRange, skipPartiallyEmittedExpressions, some, updateAsExpression, updateParen, updatePartiallyEmittedExpression, } from "./_namespaces/ts.js";
+export const nullTransformationContext = {
+    enableEmitNotification: noop,
+    enableSubstitution: noop,
+    endLexicalEnvironment: returnUndefined,
+    getCompilerOptions: () => ({}),
+    setLexicalEnvironmentFlags: noop,
+    getLexicalEnvironmentFlags: () => 0,
+    hoistVariableDeclaration: noop,
+    addInitializationStatement: noop,
+    isEmitNotificationEnabled: notImplemented,
+    isSubstitutionEnabled: notImplemented,
+    onEmitNode: noop,
+    onSubstituteNode: notImplemented,
+    readEmitHelpers: notImplemented,
+    requestEmitHelper: noop,
+    resumeLexicalEnvironment: noop,
+    startLexicalEnvironment: noop,
+    suspendLexicalEnvironment: noop,
+    addDiagnostic: noop,
+};
+// Helpers
+// Utilities
+export function createExpressionFromEntityName(node) {
+    if (isQualifiedName(node)) {
+        const left = createExpressionFromEntityName(node.left);
+        const right = getMutableClone(node.right);
+        return setTextRange(createPropertyAccess(left, right), node);
+    }
+    else {
+        return getMutableClone(node);
+    }
+}
+export function convertToFunctionBody(node, multiLine) {
+    return isBlock(node) ? node : setTextRange(createBlock([setTextRange(createReturn(node), node)], multiLine), node);
+}
+function isUseStrictPrologue(node) {
+    return isStringLiteral(node.expression) && node.expression.text === "use strict";
+}
+export function findUseStrictPrologue(statements) {
+    for (const statement of statements) {
+        if (isPrologueDirective(statement)) {
+            if (isUseStrictPrologue(statement)) {
+                return statement;
+            }
+        }
+        else {
+            break;
+        }
+    }
+    return undefined;
+}
+/**
+ * Ensures "use strict" directive is added
+ *
+ * @param statements An array of statements
+ */
+export function ensureUseStrict(statements) {
+    const foundUseStrict = findUseStrictPrologue(statements);
+    if (!foundUseStrict) {
+        return setTextRange(createNodeArray([
+            startOnNewLine(createStatement(createLiteral("use strict"))),
+            ...statements
+        ]), statements);
+    }
+    return statements;
+}
+/**
+ * Wraps the operand to a BinaryExpression in parentheses if they are needed to preserve the intended
+ * order of operations.
+ *
+ * @param binaryOperator The operator for the BinaryExpression.
+ * @param operand The operand for the BinaryExpression.
+ * @param isLeftSideOfBinary A value indicating whether the operand is the left side of the
+ *                           BinaryExpression.
+ */
+export function parenthesizeBinaryOperand(binaryOperator, operand, isLeftSideOfBinary, leftOperand) {
+    const skipped = skipPartiallyEmittedExpressions(operand);
+    // If the resulting expression is already parenthesized, we do not need to do any further processing.
+    if (skipped.kind === 200 /* SyntaxKind.ParenthesizedExpression */) {
+        return operand;
+    }
+    return binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand)
+        ? createParen(operand)
+        : operand;
+}
+// O `??` misturado ao `||` ou ao `&&` sempre parenteseado: a correção do TypeScript 5.9.3 (PR #62311, CK-65).
+function mixingBinaryOperatorsRequiresParentheses(a, b) {
+    if (a === 60 /* SyntaxKind.QuestionQuestionToken */) {
+        return b === 55 /* SyntaxKind.AmpersandAmpersandToken */ || b === 56 /* SyntaxKind.BarBarToken */;
+    }
+    if (b === 60 /* SyntaxKind.QuestionQuestionToken */) {
+        return a === 55 /* SyntaxKind.AmpersandAmpersandToken */ || a === 56 /* SyntaxKind.BarBarToken */;
+    }
+    return false;
+}
+/**
+ * Determines whether the operand to a BinaryExpression needs to be parenthesized.
+ *
+ * @param binaryOperator The operator for the BinaryExpression.
+ * @param operand The operand for the BinaryExpression.
+ * @param isLeftSideOfBinary A value indicating whether the operand is the left side of the
+ *                           BinaryExpression.
+ */
+function binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand) {
+    const emittedOperand = skipPartiallyEmittedExpressions(operand);
+    if (isBinaryExpression(emittedOperand) && mixingBinaryOperatorsRequiresParentheses(binaryOperator, emittedOperand.operatorToken.kind)) {
+        return true;
+    }
+    // If the operand has lower precedence, then it needs to be parenthesized to preserve the
+    // intent of the expression. For example, if the operand is `a + b` and the operator is
+    // `*`, then we need to parenthesize the operand to preserve the intended order of
+    // operations: `(a + b) * x`.
+    //
+    // If the operand has higher precedence, then it does not need to be parenthesized. For
+    // example, if the operand is `a * b` and the operator is `+`, then we do not need to
+    // parenthesize to preserve the intended order of operations: `a * b + x`.
+    //
+    // If the operand has the same precedence, then we need to check the associativity of
+    // the operator based on whether this is the left or right operand of the expression.
+    //
+    // For example, if `a / d` is on the right of operator `*`, we need to parenthesize
+    // to preserve the intended order of operations: `x * (a / d)`
+    //
+    // If `a ** d` is on the left of operator `**`, we need to parenthesize to preserve
+    // the intended order of operations: `(a ** b) ** c`
+    const binaryOperatorPrecedence = getOperatorPrecedence(209 /* SyntaxKind.BinaryExpression */, binaryOperator);
+    const binaryOperatorAssociativity = getOperatorAssociativity(209 /* SyntaxKind.BinaryExpression */, binaryOperator);
+    if (!isLeftSideOfBinary && operand.kind === 202 /* SyntaxKind.ArrowFunction */ && binaryOperatorPrecedence > 3) {
+        // We need to parenthesize arrow functions on the right side to avoid it being
+        // parsed as parenthesized expression: `a && (() => {})`
+        return true;
+    }
+    const operandPrecedence = getExpressionPrecedence(emittedOperand);
+    switch (compareValues(operandPrecedence, binaryOperatorPrecedence)) {
+        case -1 /* Comparison.LessThan */:
+            return true;
+        case 1 /* Comparison.GreaterThan */:
+            return false;
+        case 0 /* Comparison.EqualTo */:
+            if (isLeftSideOfBinary) {
+                // No need to parenthesize the left operand when the binary operator is
+                // left associative:
+                //  (a*b)/x    -> a*b/x
+                //  (a**b)/x   -> a**b/x
+                //
+                // Parentheses are needed for the left operand when the binary operator is
+                // right associative:
+                //  (a/b)**x   -> (a/b)**x
+                //  (a**b)**x  -> (a**b)**x
+                return binaryOperatorAssociativity === 1 /* Associativity.Right */;
+            }
+            else {
+                if (isBinaryExpression(emittedOperand)
+                    && emittedOperand.operatorToken.kind === binaryOperator) {
+                    // No need to parenthesize the right operand when the binary operator and
+                    // operand are the same and one of the following:
+                    //  x*(a*b)     => x*a*b
+                    //  x|(a|b)     => x|a|b
+                    //  x&(a&b)     => x&a&b
+                    //  x^(a^b)     => x^a^b
+                    if (operatorHasAssociativeProperty(binaryOperator)) {
+                        return false;
+                    }
+                    // No need to parenthesize the right operand when the binary operator
+                    // is plus (+) if both the left and right operands consist solely of either
+                    // literals of the same kind or binary plus (+) expressions for literals of
+                    // the same kind (recursively).
+                    //  "a"+(1+2)       => "a"+(1+2)
+                    //  "a"+("b"+"c")   => "a"+"b"+"c"
+                    if (binaryOperator === 39 /* SyntaxKind.PlusToken */) {
+                        const leftKind = leftOperand ? getLiteralKindOfBinaryPlusOperand(leftOperand) : 0 /* SyntaxKind.Unknown */;
+                        if (isLiteralKind(leftKind) && leftKind === getLiteralKindOfBinaryPlusOperand(emittedOperand)) {
+                            return false;
+                        }
+                    }
+                }
+                // No need to parenthesize the right operand when the operand is right
+                // associative:
+                //  x/(a**b)    -> x/a**b
+                //  x**(a**b)   -> x**a**b
+                //
+                // Parentheses are needed for the right operand when the operand is left
+                // associative:
+                //  x/(a*b)     -> x/(a*b)
+                //  x**(a/b)    -> x**(a/b)
+                const operandAssociativity = getExpressionAssociativity(emittedOperand);
+                return operandAssociativity === 0 /* Associativity.Left */;
+            }
+    }
+}
+/**
+ * Determines whether a binary operator is mathematically associative.
+ *
+ * @param binaryOperator The binary operator.
+ */
+function operatorHasAssociativeProperty(binaryOperator) {
+    // The following operators are associative in JavaScript:
+    //  (a*b)*c     -> a*(b*c)  -> a*b*c
+    //  (a|b)|c     -> a|(b|c)  -> a|b|c
+    //  (a&b)&c     -> a&(b&c)  -> a&b&c
+    //  (a^b)^c     -> a^(b^c)  -> a^b^c
+    //
+    // While addition is associative in mathematics, JavaScript's `+` is not
+    // guaranteed to be associative as it is overloaded with string concatenation.
+    return binaryOperator === 41 /* SyntaxKind.AsteriskToken */
+        || binaryOperator === 51 /* SyntaxKind.BarToken */
+        || binaryOperator === 50 /* SyntaxKind.AmpersandToken */
+        || binaryOperator === 52 /* SyntaxKind.CaretToken */;
+}
+/**
+ * This function determines whether an expression consists of a homogeneous set of
+ * literal expressions or binary plus expressions that all share the same literal kind.
+ * It is used to determine whether the right-hand operand of a binary plus expression can be
+ * emitted without parentheses.
+ */
+function getLiteralKindOfBinaryPlusOperand(node) {
+    node = skipPartiallyEmittedExpressions(node);
+    if (isLiteralKind(node.kind)) {
+        return node.kind;
+    }
+    if (node.kind === 209 /* SyntaxKind.BinaryExpression */ && node.operatorToken.kind === 39 /* SyntaxKind.PlusToken */) {
+        if (node.cachedLiteralKind !== undefined) {
+            return node.cachedLiteralKind;
+        }
+        const leftKind = getLiteralKindOfBinaryPlusOperand(node.left);
+        const literalKind = isLiteralKind(leftKind) && leftKind === getLiteralKindOfBinaryPlusOperand(node.right) ? leftKind :
+            0 /* SyntaxKind.Unknown */;
+        node.cachedLiteralKind = literalKind;
+        return literalKind;
+    }
+    return 0 /* SyntaxKind.Unknown */;
+}
+export function parenthesizeForConditionalHead(condition) {
+    const conditionalPrecedence = getOperatorPrecedence(210 /* SyntaxKind.ConditionalExpression */, 57 /* SyntaxKind.QuestionToken */);
+    const emittedCondition = skipPartiallyEmittedExpressions(condition);
+    const conditionPrecedence = getExpressionPrecedence(emittedCondition);
+    if (compareValues(conditionPrecedence, conditionalPrecedence) !== 1 /* Comparison.GreaterThan */) {
+        return createParen(condition);
+    }
+    return condition;
+}
+export function parenthesizeSubexpressionOfConditionalExpression(e) {
+    // per ES grammar both 'whenTrue' and 'whenFalse' parts of conditional expression are assignment expressions
+    // so in case when comma expression is introduced as a part of previous transformations
+    // if should be wrapped in parens since comma operator has the lowest precedence
+    const emittedExpression = skipPartiallyEmittedExpressions(e);
+    return isCommaSequence(emittedExpression)
+        ? createParen(e)
+        : e;
+}
+/**
+ * O `export default` aceita uma AssignmentExpression: a sequência de vírgula, escrita ou sintética, vai entre
+ * parênteses.
+ */
+export function parenthesizeDefaultExpression(e) {
+    const check = skipPartiallyEmittedExpressions(e);
+    return isCommaSequence(check) ? createParen(e) : e;
+}
+/**
+ * Wraps an expression in parentheses if it is needed in order to use the expression for
+ * property or element access.
+ *
+ * @param expr The expression node.
+ */
+export function parenthesizeForAccess(expression) {
+    const emittedExpression = skipPartiallyEmittedExpressions(expression);
+    if (isLeftHandSideExpression(emittedExpression)) {
+        return expression;
+    }
+    return setTextRange(createParen(expression), expression);
+}
+export function parenthesizePostfixOperand(operand) {
+    return isLeftHandSideExpression(operand)
+        ? operand
+        : setTextRange(createParen(operand), operand);
+}
+export function parenthesizePrefixOperand(operand) {
+    return isUnaryExpression(operand)
+        ? operand
+        : setTextRange(createParen(operand), operand);
+}
+export function parenthesizeListElements(elements) {
+    let result;
+    for (let i = 0; i < elements.length; i++) {
+        const element = parenthesizeExpressionForList(elements[i]);
+        if (result !== undefined || element !== elements[i]) {
+            if (result === undefined) {
+                result = elements.slice(0, i);
+            }
+            result.push(element);
+        }
+    }
+    if (result !== undefined) {
+        return setTextRange(createNodeArray(result, elements.hasTrailingComma), elements);
+    }
+    return elements;
+}
+export function parenthesizeExpressionForList(expression) {
+    const emittedExpression = skipPartiallyEmittedExpressions(expression);
+    const expressionPrecedence = getExpressionPrecedence(emittedExpression);
+    const commaPrecedence = getOperatorPrecedence(209 /* SyntaxKind.BinaryExpression */, 27 /* SyntaxKind.CommaToken */);
+    return expressionPrecedence > commaPrecedence
+        ? expression
+        : setTextRange(createParen(expression), expression);
+}
+export function parenthesizeExpressionForExpressionStatement(expression) {
+    const emittedExpression = skipPartiallyEmittedExpressions(expression);
+    if (isCallExpression(emittedExpression)) {
+        const callee = emittedExpression.expression;
+        const kind = skipPartiallyEmittedExpressions(callee).kind;
+        if (kind === 202 /* SyntaxKind.ArrowFunction */) {
+            const mutableCall = getMutableClone(emittedExpression);
+            mutableCall.expression = setTextRange(createParen(callee), callee);
+            return recreateOuterExpressions(expression, mutableCall, 8 /* OuterExpressionKinds.PartiallyEmittedExpressions */);
+        }
+    }
+    const leftmostExpressionKind = getLeftmostExpression(emittedExpression).kind;
+    if (leftmostExpressionKind === 193 /* SyntaxKind.ObjectLiteralExpression */) {
+        return setTextRange(createParen(expression), expression);
+    }
+    return expression;
+}
+export function parenthesizeConditionalTypeMember(member) {
+    return member.kind === 180 /* SyntaxKind.ConditionalType */ ? createParenthesizedType(member) : member;
+}
+export function parenthesizeElementTypeMember(member) {
+    switch (member.kind) {
+        case 178 /* SyntaxKind.UnionType */:
+        case 179 /* SyntaxKind.IntersectionType */:
+        case 170 /* SyntaxKind.FunctionType */:
+            return createParenthesizedType(member);
+    }
+    return parenthesizeConditionalTypeMember(member);
+}
+export function parenthesizeArrayTypeMember(member) {
+    switch (member.kind) {
+        case 172 /* SyntaxKind.TypeQuery */:
+        case 184 /* SyntaxKind.TypeOperator */:
+        case 181 /* SyntaxKind.InferType */:
+            return createParenthesizedType(member);
+    }
+    return parenthesizeElementTypeMember(member);
+}
+export function parenthesizeElementTypeMembers(members) {
+    return createNodeArray(sameMap(members, parenthesizeElementTypeMember));
+}
+export function parenthesizeTypeParameters(typeParameters) {
+    if (some(typeParameters)) {
+        const params = [];
+        for (let i = 0; i < typeParameters.length; ++i) {
+            const entry = typeParameters[i];
+            params.push(i === 0 && isFunctionTypeNode(entry) && entry.typeParameters ?
+                createParenthesizedType(entry) :
+                entry);
+        }
+        return createNodeArray(params);
+    }
+}
+export function getLeftmostExpression(node) {
+    while (true) {
+        switch (node.kind) {
+            case 208 /* SyntaxKind.PostfixUnaryExpression */:
+                node = node.operand;
+                continue;
+            case 209 /* SyntaxKind.BinaryExpression */:
+                node = node.left;
+                continue;
+            case 210 /* SyntaxKind.ConditionalExpression */:
+                node = node.condition;
+                continue;
+            case 196 /* SyntaxKind.CallExpression */:
+            case 217 /* SyntaxKind.AsExpression */:
+            case 195 /* SyntaxKind.ElementAccessExpression */:
+            case 194 /* SyntaxKind.PropertyAccessExpression */:
+            case 326 /* SyntaxKind.PartiallyEmittedExpression */:
+                node = node.expression;
+                continue;
+        }
+        return node;
+    }
+}
+export function parenthesizeConciseBody(body) {
+    if (!isBlock(body) && (isCommaSequence(body) || getLeftmostExpression(body).kind === 193 /* SyntaxKind.ObjectLiteralExpression */)) {
+        return setTextRange(createParen(body), body);
+    }
+    return body;
+}
+export function isCommaSequence(node) {
+    return node.kind === 209 /* SyntaxKind.BinaryExpression */ && node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ ||
+        node.kind === 327 /* SyntaxKind.CommaListExpression */;
+}
+export var OuterExpressionKinds;
+(function (OuterExpressionKinds) {
+    OuterExpressionKinds[OuterExpressionKinds["Parentheses"] = 1] = "Parentheses";
+    OuterExpressionKinds[OuterExpressionKinds["TypeAssertions"] = 2] = "TypeAssertions";
+    OuterExpressionKinds[OuterExpressionKinds["PartiallyEmittedExpressions"] = 8] = "PartiallyEmittedExpressions";
+    OuterExpressionKinds[OuterExpressionKinds["Assertions"] = 2] = "Assertions";
+    OuterExpressionKinds[OuterExpressionKinds["All"] = 11] = "All";
+})(OuterExpressionKinds || (OuterExpressionKinds = {}));
+export function isOuterExpression(node, kinds = 11 /* OuterExpressionKinds.All */) {
+    switch (node.kind) {
+        case 200 /* SyntaxKind.ParenthesizedExpression */:
+            return (kinds & 1 /* OuterExpressionKinds.Parentheses */) !== 0;
+        case 217 /* SyntaxKind.AsExpression */:
+            return (kinds & 2 /* OuterExpressionKinds.TypeAssertions */) !== 0;
+        case 326 /* SyntaxKind.PartiallyEmittedExpression */:
+            return (kinds & 8 /* OuterExpressionKinds.PartiallyEmittedExpressions */) !== 0;
+    }
+    return false;
+}
+export function skipOuterExpressions(node, kinds = 11 /* OuterExpressionKinds.All */) {
+    while (isOuterExpression(node, kinds)) {
+        node = node.expression;
+    }
+    return node;
+}
+function updateOuterExpression(outerExpression, expression) {
+    switch (outerExpression.kind) {
+        case 200 /* SyntaxKind.ParenthesizedExpression */: return updateParen(outerExpression, expression);
+        case 217 /* SyntaxKind.AsExpression */: return updateAsExpression(outerExpression, expression, outerExpression.type);
+        case 326 /* SyntaxKind.PartiallyEmittedExpression */: return updatePartiallyEmittedExpression(outerExpression, expression);
+    }
+}
+/**
+ * Determines whether a node is a parenthesized expression that can be ignored when recreating outer expressions.
+ *
+ * A parenthesized expression can be ignored when all of the following are true:
+ *
+ * - It's `pos` and `end` are not -1
+ * - It does not have a custom source map range
+ * - It does not have a custom comment range
+ * - It does not have synthetic leading or trailing comments
+ *
+ * If an outermost parenthesized expression is ignored, but the containing expression requires a parentheses around
+ * the expression to maintain precedence, a new parenthesized expression should be created automatically when
+ * the containing expression is created/updated.
+ */
+function isIgnorableParen(node) {
+    return node.kind === 200 /* SyntaxKind.ParenthesizedExpression */
+        && nodeIsSynthesized(node)
+        && nodeIsSynthesized(getSourceMapRange(node))
+        && nodeIsSynthesized(getCommentRange(node))
+        && !some(getSyntheticLeadingComments(node))
+        && !some(getSyntheticTrailingComments(node));
+}
+export function recreateOuterExpressions(outerExpression, innerExpression, kinds = 11 /* OuterExpressionKinds.All */) {
+    if (outerExpression && isOuterExpression(outerExpression, kinds) && !isIgnorableParen(outerExpression)) {
+        return updateOuterExpression(outerExpression, recreateOuterExpressions(outerExpression.expression, innerExpression));
+    }
+    return innerExpression;
+}
+export function startOnNewLine(node) {
+    return setStartsOnNewLine(node, /*newLine*/ true);
+}
+/**
+ * Gets the initializer of an BindingOrAssignmentElement.
+ */
+export function getInitializerOfBindingOrAssignmentElement(bindingElement) {
+    if (isDeclarationBindingElement(bindingElement)) {
+        // `1` in `let { a = 1 } = ...`
+        // `1` in `let { a: b = 1 } = ...`
+        // `1` in `let { a: {b} = 1 } = ...`
+        // `1` in `let { a: [b] = 1 } = ...`
+        // `1` in `let [a = 1] = ...`
+        // `1` in `let [{a} = 1] = ...`
+        // `1` in `let [[a] = 1] = ...`
+        return bindingElement.initializer;
+    }
+    if (isPropertyAssignment(bindingElement)) {
+        // `1` in `({ a: b = 1 } = ...)`
+        // `1` in `({ a: {b} = 1 } = ...)`
+        // `1` in `({ a: [b] = 1 } = ...)`
+        const initializer = bindingElement.initializer;
+        return isAssignmentExpression(initializer, /*excludeCompoundAssignment*/ true)
+            ? initializer.right
+            : undefined;
+    }
+    if (isShorthandPropertyAssignment(bindingElement)) {
+        // `1` in `({ a = 1 } = ...)`
+        return bindingElement.objectAssignmentInitializer;
+    }
+    if (isAssignmentExpression(bindingElement, /*excludeCompoundAssignment*/ true)) {
+        // `1` in `[a = 1] = ...`
+        // `1` in `[{a} = 1] = ...`
+        // `1` in `[[a] = 1] = ...`
+        return bindingElement.right;
+    }
+    if (isSpreadElement(bindingElement)) {
+        // Recovery consistent with existing emit.
+        return getInitializerOfBindingOrAssignmentElement(bindingElement.expression);
+    }
+}
+/**
+ * Gets the name of an BindingOrAssignmentElement.
+ */
+export function getTargetOfBindingOrAssignmentElement(bindingElement) {
+    if (isDeclarationBindingElement(bindingElement)) {
+        // `a` in `let { a } = ...`
+        // `a` in `let { a = 1 } = ...`
+        // `b` in `let { a: b } = ...`
+        // `b` in `let { a: b = 1 } = ...`
+        // `a` in `let { ...a } = ...`
+        // `{b}` in `let { a: {b} } = ...`
+        // `{b}` in `let { a: {b} = 1 } = ...`
+        // `[b]` in `let { a: [b] } = ...`
+        // `[b]` in `let { a: [b] = 1 } = ...`
+        // `a` in `let [a] = ...`
+        // `a` in `let [a = 1] = ...`
+        // `a` in `let [...a] = ...`
+        // `{a}` in `let [{a}] = ...`
+        // `{a}` in `let [{a} = 1] = ...`
+        // `[a]` in `let [[a]] = ...`
+        // `[a]` in `let [[a] = 1] = ...`
+        return bindingElement.name;
+    }
+    if (isObjectLiteralElementLike(bindingElement)) {
+        switch (bindingElement.kind) {
+            case 281 /* SyntaxKind.PropertyAssignment */:
+                // `b` in `({ a: b } = ...)`
+                // `b` in `({ a: b = 1 } = ...)`
+                // `{b}` in `({ a: {b} } = ...)`
+                // `{b}` in `({ a: {b} = 1 } = ...)`
+                // `[b]` in `({ a: [b] } = ...)`
+                // `[b]` in `({ a: [b] = 1 } = ...)`
+                // `b.c` in `({ a: b.c } = ...)`
+                // `b.c` in `({ a: b.c = 1 } = ...)`
+                // `b[0]` in `({ a: b[0] } = ...)`
+                // `b[0]` in `({ a: b[0] = 1 } = ...)`
+                return getTargetOfBindingOrAssignmentElement(bindingElement.initializer);
+            case 282 /* SyntaxKind.ShorthandPropertyAssignment */:
+                // `a` in `({ a } = ...)`
+                // `a` in `({ a = 1 } = ...)`
+                return bindingElement.name;
+            case 283 /* SyntaxKind.SpreadAssignment */:
+                // `a` in `({ ...a } = ...)`
+                return getTargetOfBindingOrAssignmentElement(bindingElement.expression);
+        }
+        // no target
+        return undefined;
+    }
+    if (isAssignmentExpression(bindingElement, /*excludeCompoundAssignment*/ true)) {
+        // `a` in `[a = 1] = ...`
+        // `{a}` in `[{a} = 1] = ...`
+        // `[a]` in `[[a] = 1] = ...`
+        // `a.b` in `[a.b = 1] = ...`
+        // `a[0]` in `[a[0] = 1] = ...`
+        return getTargetOfBindingOrAssignmentElement(bindingElement.left);
+    }
+    if (isSpreadElement(bindingElement)) {
+        // `a` in `[...a] = ...`
+        return getTargetOfBindingOrAssignmentElement(bindingElement.expression);
+    }
+    // `a` in `[a] = ...`
+    // `{a}` in `[{a}] = ...`
+    // `[a]` in `[[a]] = ...`
+    // `a.b` in `[a.b] = ...`
+    // `a[0]` in `[a[0]] = ...`
+    return bindingElement;
+}
+export function convertToArrayAssignmentElement(element) {
+    if (isBindingElement(element)) {
+        if (element.dotDotDotToken) {
+            Debug.assertNode(element.name, isIdentifier);
+            return setOriginalNode(setTextRange(createSpread(element.name), element), element);
+        }
+        const expression = convertToAssignmentElementTarget(element.name);
+        return element.initializer
+            ? setOriginalNode(setTextRange(createAssignment(expression, element.initializer), element), element)
+            : expression;
+    }
+    Debug.assertNode(element, isExpression);
+    return element;
+}
+export function convertToObjectAssignmentElement(element) {
+    if (isBindingElement(element)) {
+        if (element.dotDotDotToken) {
+            Debug.assertNode(element.name, isIdentifier);
+            return setOriginalNode(setTextRange(createSpreadAssignment(element.name), element), element);
+        }
+        if (element.propertyName) {
+            const expression = convertToAssignmentElementTarget(element.name);
+            return setOriginalNode(setTextRange(createPropertyAssignment(element.propertyName, element.initializer ? createAssignment(expression, element.initializer) : expression), element), element);
+        }
+        Debug.assertNode(element.name, isIdentifier);
+        return setOriginalNode(setTextRange(createShorthandPropertyAssignment(element.name, element.initializer), element), element);
+    }
+    Debug.assertNode(element, isObjectLiteralElementLike);
+    return element;
+}
+export function convertToAssignmentPattern(node) {
+    switch (node.kind) {
+        case 190 /* SyntaxKind.ArrayBindingPattern */:
+        case 192 /* SyntaxKind.ArrayLiteralExpression */:
+            return convertToArrayAssignmentPattern(node);
+        case 189 /* SyntaxKind.ObjectBindingPattern */:
+        case 193 /* SyntaxKind.ObjectLiteralExpression */:
+            return convertToObjectAssignmentPattern(node);
+    }
+}
+export function convertToObjectAssignmentPattern(node) {
+    if (isObjectBindingPattern(node)) {
+        return setOriginalNode(setTextRange(createObjectLiteral(map(node.elements, convertToObjectAssignmentElement)), node), node);
+    }
+    Debug.assertNode(node, isObjectLiteralExpression);
+    return node;
+}
+export function convertToArrayAssignmentPattern(node) {
+    if (isArrayBindingPattern(node)) {
+        return setOriginalNode(setTextRange(createArrayLiteral(map(node.elements, convertToArrayAssignmentElement)), node), node);
+    }
+    Debug.assertNode(node, isArrayLiteralExpression);
+    return node;
+}
+export function convertToAssignmentElementTarget(node) {
+    if (isBindingPattern(node)) {
+        return convertToAssignmentPattern(node);
+    }
+    Debug.assertNode(node, isExpression);
+    return node;
+}