| {"version":3,"file":"index.js","sources":["../../babel-compat-data/corejs2-built-ins.js","../src/shouldStoreRHSInTemporaryVariable.ts","../src/index.ts"],"sourcesContent":["module.exports = require(\"./data/corejs2-built-ins.json\");\n","import { types as t } from \"@babel/core\";\n\nconst { isObjectProperty } = t;\n/**\n * This is a helper function to determine if we should create an intermediate variable\n * such that the RHS of an assignment is not duplicated.\n *\n * See https://github.com/babel/babel/pull/13711#issuecomment-914388382 for discussion\n * on further optimizations.\n */\nexport default function shouldStoreRHSInTemporaryVariable(node: t.LVal) {\n if (t.isArrayPattern(node)) {\n const nonNullElements = node.elements.filter(element => element !== null);\n if (nonNullElements.length > 1) return true;\n else return shouldStoreRHSInTemporaryVariable(nonNullElements[0]);\n } else if (t.isObjectPattern(node)) {\n const { properties } = node;\n if (properties.length > 1) return true;\n else if (properties.length === 0) return false;\n else {\n const firstProperty = properties[0];\n if (isObjectProperty(firstProperty)) {\n // the value of the property must be an LVal\n return shouldStoreRHSInTemporaryVariable(firstProperty.value as t.LVal);\n } else {\n return shouldStoreRHSInTemporaryVariable(firstProperty);\n }\n }\n } else if (t.isAssignmentPattern(node)) {\n return shouldStoreRHSInTemporaryVariable(node.left);\n } else if (t.isRestElement(node)) {\n if (t.isIdentifier(node.argument)) return true;\n return shouldStoreRHSInTemporaryVariable(node.argument);\n } else {\n // node is Identifier or MemberExpression\n return false;\n }\n}\n","import { declare } from \"@babel/helper-plugin-utils\";\nimport syntaxObjectRestSpread from \"@babel/plugin-syntax-object-rest-spread\";\nimport { types as t } from \"@babel/core\";\nimport type { PluginPass } from \"@babel/core\";\nimport type { NodePath, Visitor, Scope } from \"@babel/traverse\";\nimport { convertFunctionParams } from \"@babel/plugin-transform-parameters\";\nimport { isRequired } from \"@babel/helper-compilation-targets\";\nimport compatData from \"@babel/compat-data/corejs2-built-ins\";\nimport shouldStoreRHSInTemporaryVariable from \"./shouldStoreRHSInTemporaryVariable\";\n\nconst { isAssignmentPattern, isObjectProperty } = t;\n// @babel/types <=7.3.3 counts FOO as referenced in var { x: FOO }.\n// We need to detect this bug to know if \"unused\" means 0 or 1 references.\nif (!process.env.BABEL_8_BREAKING) {\n const node = t.identifier(\"a\");\n const property = t.objectProperty(t.identifier(\"key\"), node);\n const pattern = t.objectPattern([property]);\n\n // eslint-disable-next-line no-var\n var ZERO_REFS = t.isReferenced(node, property, pattern) ? 1 : 0;\n}\n\nexport default declare((api, opts) => {\n api.assertVersion(7);\n\n const targets = api.targets();\n const supportsObjectAssign = !isRequired(\"es6.object.assign\", targets, {\n compatData,\n });\n\n const { useBuiltIns = supportsObjectAssign, loose = false } = opts;\n\n if (typeof loose !== \"boolean\") {\n throw new Error(\".loose must be a boolean, or undefined\");\n }\n\n const ignoreFunctionLength = api.assumption(\"ignoreFunctionLength\") ?? loose;\n const objectRestNoSymbols = api.assumption(\"objectRestNoSymbols\") ?? loose;\n const pureGetters = api.assumption(\"pureGetters\") ?? loose;\n const setSpreadProperties = api.assumption(\"setSpreadProperties\") ?? loose;\n\n function getExtendsHelper(\n file: PluginPass,\n ): t.MemberExpression | t.Identifier {\n return useBuiltIns\n ? t.memberExpression(t.identifier(\"Object\"), t.identifier(\"assign\"))\n : file.addHelper(\"extends\");\n }\n\n function hasRestElement(path) {\n let foundRestElement = false;\n visitRestElements(path, restElement => {\n foundRestElement = true;\n restElement.stop();\n });\n return foundRestElement;\n }\n\n function hasObjectPatternRestElement(path: NodePath): boolean {\n let foundRestElement = false;\n visitRestElements(path, restElement => {\n if (restElement.parentPath.isObjectPattern()) {\n foundRestElement = true;\n restElement.stop();\n }\n });\n return foundRestElement;\n }\n\n function visitRestElements(\n path: NodePath,\n visitor: (path: NodePath<t.RestElement>) => any,\n ) {\n path.traverse({\n Expression(path) {\n const { parent, key } = path;\n if (\n (isAssignmentPattern(parent) && key === \"right\") ||\n (isObjectProperty(parent) && parent.computed && key === \"key\")\n ) {\n path.skip();\n }\n },\n RestElement: visitor,\n });\n }\n\n function hasSpread(node: t.ObjectExpression): boolean {\n for (const prop of node.properties) {\n if (t.isSpreadElement(prop)) {\n return true;\n }\n }\n return false;\n }\n\n // returns an array of all keys of an object, and a status flag indicating if all extracted keys\n // were converted to stringLiterals or not\n // e.g. extracts {keys: [\"a\", \"b\", \"3\", ++x], allLiteral: false }\n // from ast of {a: \"foo\", b, 3: \"bar\", [++x]: \"baz\"}\n function extractNormalizedKeys(node: t.ObjectPattern) {\n // RestElement has been removed in createObjectRest\n const props = node.properties as t.ObjectProperty[];\n const keys: t.Expression[] = [];\n let allLiteral = true;\n let hasTemplateLiteral = false;\n\n for (const prop of props) {\n if (t.isIdentifier(prop.key) && !prop.computed) {\n // since a key {a: 3} is equivalent to {\"a\": 3}, use the latter\n keys.push(t.stringLiteral(prop.key.name));\n } else if (t.isTemplateLiteral(prop.key)) {\n keys.push(t.cloneNode(prop.key));\n hasTemplateLiteral = true;\n } else if (t.isLiteral(prop.key)) {\n keys.push(\n t.stringLiteral(\n String(\n //@ts-ignore prop.key can not be a NullLiteral\n prop.key.value,\n ),\n ),\n );\n } else {\n keys.push(t.cloneNode(prop.key));\n allLiteral = false;\n }\n }\n\n return { keys, allLiteral, hasTemplateLiteral };\n }\n\n // replaces impure computed keys with new identifiers\n // and returns variable declarators of these new identifiers\n function replaceImpureComputedKeys(\n properties: NodePath<t.ObjectProperty>[],\n scope: Scope,\n ) {\n const impureComputedPropertyDeclarators: t.VariableDeclarator[] = [];\n for (const propPath of properties) {\n const key = propPath.get(\"key\");\n if (propPath.node.computed && !key.isPure()) {\n const name = scope.generateUidBasedOnNode(key.node);\n const declarator = t.variableDeclarator(t.identifier(name), key.node);\n impureComputedPropertyDeclarators.push(declarator);\n key.replaceWith(t.identifier(name));\n }\n }\n return impureComputedPropertyDeclarators;\n }\n\n function removeUnusedExcludedKeys(path: NodePath<t.ObjectPattern>): void {\n const bindings = path.getOuterBindingIdentifierPaths();\n\n Object.keys(bindings).forEach(bindingName => {\n const bindingParentPath = bindings[bindingName].parentPath;\n if (\n path.scope.getBinding(bindingName).references >\n (process.env.BABEL_8_BREAKING ? 0 : ZERO_REFS) ||\n !bindingParentPath.isObjectProperty()\n ) {\n return;\n }\n bindingParentPath.remove();\n });\n }\n\n //expects path to an object pattern\n function createObjectRest(\n path: NodePath<t.ObjectPattern>,\n file: PluginPass,\n objRef: t.Identifier | t.MemberExpression,\n ): [t.VariableDeclarator[], t.LVal, t.CallExpression] {\n const props = path.get(\"properties\");\n const last = props[props.length - 1];\n t.assertRestElement(last.node);\n const restElement = t.cloneNode(last.node);\n last.remove();\n\n const impureComputedPropertyDeclarators = replaceImpureComputedKeys(\n path.get(\"properties\") as NodePath<t.ObjectProperty>[],\n path.scope,\n );\n const { keys, allLiteral, hasTemplateLiteral } = extractNormalizedKeys(\n path.node,\n );\n\n if (keys.length === 0) {\n return [\n impureComputedPropertyDeclarators,\n restElement.argument,\n t.callExpression(getExtendsHelper(file), [\n t.objectExpression([]),\n t.cloneNode(objRef),\n ]),\n ];\n }\n\n let keyExpression;\n if (!allLiteral) {\n // map to toPropertyKey to handle the possible non-string values\n keyExpression = t.callExpression(\n t.memberExpression(t.arrayExpression(keys), t.identifier(\"map\")),\n [file.addHelper(\"toPropertyKey\")],\n );\n } else {\n keyExpression = t.arrayExpression(keys);\n\n if (!hasTemplateLiteral && !t.isProgram(path.scope.block)) {\n // Hoist definition of excluded keys, so that it's not created each time.\n const program = path.findParent(path => path.isProgram());\n const id = path.scope.generateUidIdentifier(\"excluded\");\n\n program.scope.push({\n id,\n init: keyExpression,\n kind: \"const\",\n });\n\n keyExpression = t.cloneNode(id);\n }\n }\n\n return [\n impureComputedPropertyDeclarators,\n restElement.argument,\n t.callExpression(\n file.addHelper(\n `objectWithoutProperties${objectRestNoSymbols ? \"Loose\" : \"\"}`,\n ),\n [t.cloneNode(objRef), keyExpression],\n ),\n ];\n }\n\n function replaceRestElement(\n parentPath: NodePath<t.Function | t.CatchClause>,\n paramPath: NodePath,\n container?: t.VariableDeclaration[],\n ): void {\n if (paramPath.isAssignmentPattern()) {\n replaceRestElement(parentPath, paramPath.get(\"left\"), container);\n return;\n }\n\n if (paramPath.isArrayPattern() && hasRestElement(paramPath)) {\n const elements = paramPath.get(\"elements\");\n\n for (let i = 0; i < elements.length; i++) {\n replaceRestElement(parentPath, elements[i], container);\n }\n }\n\n if (paramPath.isObjectPattern() && hasRestElement(paramPath)) {\n const uid = parentPath.scope.generateUidIdentifier(\"ref\");\n\n const declar = t.variableDeclaration(\"let\", [\n t.variableDeclarator(paramPath.node, uid),\n ]);\n\n if (container) {\n container.push(declar);\n } else {\n parentPath.ensureBlock();\n parentPath.get(\"body\").unshiftContainer(\"body\", declar);\n }\n paramPath.replaceWith(t.cloneNode(uid));\n }\n }\n\n return {\n name: \"proposal-object-rest-spread\",\n inherits: syntaxObjectRestSpread.default,\n\n visitor: {\n // function a({ b, ...c }) {}\n Function(path) {\n const params = path.get(\"params\");\n const paramsWithRestElement = new Set();\n const idsInRestParams = new Set();\n for (let i = 0; i < params.length; ++i) {\n const param = params[i];\n if (hasRestElement(param)) {\n paramsWithRestElement.add(i);\n for (const name of Object.keys(param.getBindingIdentifiers())) {\n idsInRestParams.add(name);\n }\n }\n }\n\n // if true, a parameter exists that has an id in its initializer\n // that is also an id bound in a rest parameter\n // example: f({...R}, a = R)\n let idInRest = false;\n\n const IdentifierHandler = function (path, functionScope) {\n const name = path.node.name;\n if (\n path.scope.getBinding(name) === functionScope.getBinding(name) &&\n idsInRestParams.has(name)\n ) {\n idInRest = true;\n path.stop();\n }\n };\n\n let i;\n for (i = 0; i < params.length && !idInRest; ++i) {\n const param = params[i];\n if (!paramsWithRestElement.has(i)) {\n if (param.isReferencedIdentifier() || param.isBindingIdentifier()) {\n IdentifierHandler(path, path.scope);\n } else {\n param.traverse(\n {\n \"Scope|TypeAnnotation|TSTypeAnnotation\": path => path.skip(),\n \"ReferencedIdentifier|BindingIdentifier\": IdentifierHandler,\n },\n path.scope,\n );\n }\n }\n }\n\n if (!idInRest) {\n for (let i = 0; i < params.length; ++i) {\n const param = params[i];\n if (paramsWithRestElement.has(i)) {\n replaceRestElement(path, param);\n }\n }\n } else {\n const shouldTransformParam = idx =>\n idx >= i - 1 || paramsWithRestElement.has(idx);\n convertFunctionParams(\n path,\n ignoreFunctionLength,\n shouldTransformParam,\n replaceRestElement,\n );\n }\n },\n\n // adapted from transform-destructuring/src/index.js#pushObjectRest\n // const { a, ...b } = c;\n VariableDeclarator(path, file) {\n if (!path.get(\"id\").isObjectPattern()) {\n return;\n }\n\n let insertionPath = path;\n const originalPath = path;\n\n visitRestElements(path.get(\"id\"), path => {\n if (!path.parentPath.isObjectPattern()) {\n // Return early if the parent is not an ObjectPattern, but\n // (for example) an ArrayPattern or Function, because that\n // means this RestElement is an not an object property.\n return;\n }\n\n if (\n // skip single-property case, e.g.\n // const { ...x } = foo();\n // since the RHS will not be duplicated\n shouldStoreRHSInTemporaryVariable(originalPath.node.id) &&\n !t.isIdentifier(originalPath.node.init)\n ) {\n // const { a, ...b } = foo();\n // to avoid calling foo() twice, as a first step convert it to:\n // const _foo = foo(),\n // { a, ...b } = _foo;\n const initRef = path.scope.generateUidIdentifierBasedOnNode(\n originalPath.node.init,\n \"ref\",\n );\n // insert _foo = foo()\n originalPath.insertBefore(\n t.variableDeclarator(initRef, originalPath.node.init),\n );\n // replace foo() with _foo\n originalPath.replaceWith(\n t.variableDeclarator(originalPath.node.id, t.cloneNode(initRef)),\n );\n\n return;\n }\n\n let ref = originalPath.node.init;\n const refPropertyPath: NodePath<t.ObjectProperty>[] = [];\n let kind;\n\n path.findParent((path: NodePath): boolean => {\n if (path.isObjectProperty()) {\n refPropertyPath.unshift(path);\n } else if (path.isVariableDeclarator()) {\n kind = (path.parentPath as NodePath<t.VariableDeclaration>).node\n .kind;\n return true;\n }\n });\n\n const impureObjRefComputedDeclarators = replaceImpureComputedKeys(\n refPropertyPath,\n path.scope,\n );\n refPropertyPath.forEach(prop => {\n const { node } = prop;\n ref = t.memberExpression(\n ref,\n t.cloneNode(node.key),\n node.computed || t.isLiteral(node.key),\n );\n });\n\n //@ts-expect-error: findParent can not apply assertions on result shape\n const objectPatternPath: NodePath<t.ObjectPattern> = path.findParent(\n path => path.isObjectPattern(),\n );\n\n const [impureComputedPropertyDeclarators, argument, callExpression] =\n createObjectRest(\n objectPatternPath,\n file,\n ref as t.MemberExpression,\n );\n\n if (pureGetters) {\n removeUnusedExcludedKeys(objectPatternPath);\n }\n\n t.assertIdentifier(argument);\n\n insertionPath.insertBefore(impureComputedPropertyDeclarators);\n\n insertionPath.insertBefore(impureObjRefComputedDeclarators);\n\n insertionPath = insertionPath.insertAfter(\n t.variableDeclarator(argument, callExpression),\n )[0] as NodePath<t.VariableDeclarator>;\n\n path.scope.registerBinding(kind, insertionPath);\n\n if (objectPatternPath.node.properties.length === 0) {\n objectPatternPath\n .findParent(\n path => path.isObjectProperty() || path.isVariableDeclarator(),\n )\n .remove();\n }\n });\n },\n\n // taken from transform-destructuring/src/index.js#visitor\n // export var { a, ...b } = c;\n ExportNamedDeclaration(path) {\n const declaration = path.get(\"declaration\");\n if (!declaration.isVariableDeclaration()) return;\n\n const hasRest = declaration\n .get(\"declarations\")\n .some(path => hasObjectPatternRestElement(path.get(\"id\")));\n if (!hasRest) return;\n\n const specifiers = [];\n\n for (const name of Object.keys(path.getOuterBindingIdentifiers(true))) {\n specifiers.push(\n t.exportSpecifier(t.identifier(name), t.identifier(name)),\n );\n }\n\n // Split the declaration and export list into two declarations so that the variable\n // declaration can be split up later without needing to worry about not being a\n // top-level statement.\n path.replaceWith(declaration.node);\n path.insertAfter(t.exportNamedDeclaration(null, specifiers));\n },\n\n // try {} catch ({a, ...b}) {}\n CatchClause(path) {\n const paramPath = path.get(\"param\");\n replaceRestElement(path, paramPath);\n },\n\n // ({a, ...b} = c);\n AssignmentExpression(path, file) {\n const leftPath = path.get(\"left\");\n if (leftPath.isObjectPattern() && hasRestElement(leftPath)) {\n const nodes = [];\n\n const refName = path.scope.generateUidBasedOnNode(\n path.node.right,\n \"ref\",\n );\n\n nodes.push(\n t.variableDeclaration(\"var\", [\n t.variableDeclarator(t.identifier(refName), path.node.right),\n ]),\n );\n\n const [impureComputedPropertyDeclarators, argument, callExpression] =\n createObjectRest(leftPath, file, t.identifier(refName));\n\n if (impureComputedPropertyDeclarators.length > 0) {\n nodes.push(\n t.variableDeclaration(\"var\", impureComputedPropertyDeclarators),\n );\n }\n\n const nodeWithoutSpread = t.cloneNode(path.node);\n nodeWithoutSpread.right = t.identifier(refName);\n nodes.push(t.expressionStatement(nodeWithoutSpread));\n nodes.push(\n t.toStatement(\n t.assignmentExpression(\"=\", argument, callExpression),\n ),\n );\n nodes.push(t.expressionStatement(t.identifier(refName)));\n\n path.replaceWithMultiple(nodes);\n }\n },\n\n // taken from transform-destructuring/src/index.js#visitor\n ForXStatement(path) {\n const { node, scope } = path;\n const leftPath = path.get(\"left\");\n const left = node.left;\n\n if (!hasObjectPatternRestElement(leftPath)) {\n return;\n }\n\n if (!t.isVariableDeclaration(left)) {\n // for ({a, ...b} of []) {}\n const temp = scope.generateUidIdentifier(\"ref\");\n\n node.left = t.variableDeclaration(\"var\", [\n t.variableDeclarator(temp),\n ]);\n\n path.ensureBlock();\n const body = node.body as t.BlockStatement;\n\n if (body.body.length === 0 && path.isCompletionRecord()) {\n body.body.unshift(\n t.expressionStatement(scope.buildUndefinedNode()),\n );\n }\n\n body.body.unshift(\n t.expressionStatement(\n t.assignmentExpression(\"=\", left, t.cloneNode(temp)),\n ),\n );\n } else {\n // for (var {a, ...b} of []) {}\n const pattern = left.declarations[0].id;\n\n const key = scope.generateUidIdentifier(\"ref\");\n node.left = t.variableDeclaration(left.kind, [\n t.variableDeclarator(key, null),\n ]);\n\n path.ensureBlock();\n const body = node.body as t.BlockStatement;\n\n body.body.unshift(\n t.variableDeclaration(node.left.kind, [\n t.variableDeclarator(pattern, t.cloneNode(key)),\n ]),\n );\n }\n },\n\n // [{a, ...b}] = c;\n ArrayPattern(path) {\n const objectPatterns = [];\n\n visitRestElements(path, path => {\n if (!path.parentPath.isObjectPattern()) {\n // Return early if the parent is not an ObjectPattern, but\n // (for example) an ArrayPattern or Function, because that\n // means this RestElement is an not an object property.\n return;\n }\n\n const objectPattern = path.parentPath;\n\n const uid = path.scope.generateUidIdentifier(\"ref\");\n objectPatterns.push(t.variableDeclarator(objectPattern.node, uid));\n\n objectPattern.replaceWith(t.cloneNode(uid));\n path.skip();\n });\n\n if (objectPatterns.length > 0) {\n const statementPath = path.getStatementParent();\n const statementNode = statementPath.node;\n const kind =\n statementNode.type === \"VariableDeclaration\"\n ? statementNode.kind\n : \"var\";\n statementPath.insertAfter(\n t.variableDeclaration(kind, objectPatterns),\n );\n }\n },\n\n // var a = { ...b, ...c }\n ObjectExpression(path, file) {\n if (!hasSpread(path.node)) return;\n\n let helper;\n if (setSpreadProperties) {\n helper = getExtendsHelper(file);\n } else {\n try {\n helper = file.addHelper(\"objectSpread2\");\n } catch {\n // TODO: This is needed to workaround https://github.com/babel/babel/issues/10187\n // and https://github.com/babel/babel/issues/10179 for older @babel/core versions\n // where #10187 isn't fixed.\n this.file.declarations[\"objectSpread2\"] = null;\n\n // objectSpread2 has been introduced in v7.5.0\n // We have to maintain backward compatibility.\n helper = file.addHelper(\"objectSpread\");\n }\n }\n\n let exp = null;\n let props = [];\n\n function make() {\n const hadProps = props.length > 0;\n const obj = t.objectExpression(props);\n props = [];\n\n if (!exp) {\n exp = t.callExpression(helper, [obj]);\n return;\n }\n\n // When we can assume that getters are pure and don't depend on\n // the order of evaluation, we can avoid making multiple calls.\n if (pureGetters) {\n if (hadProps) {\n exp.arguments.push(obj);\n }\n return;\n }\n\n exp = t.callExpression(t.cloneNode(helper), [\n exp,\n // If we have static props, we need to insert an empty object\n // because the odd arguments are copied with [[Get]], not\n // [[GetOwnProperty]]\n ...(hadProps ? [t.objectExpression([]), obj] : []),\n ]);\n }\n\n for (const prop of path.node.properties) {\n if (t.isSpreadElement(prop)) {\n make();\n exp.arguments.push(prop.argument);\n } else {\n props.push(prop);\n }\n }\n\n if (props.length) make();\n\n path.replaceWith(exp);\n },\n } as Visitor<PluginPass>,\n };\n});\n"],"names":["require$$0","isObjectProperty","t","shouldStoreRHSInTemporaryVariable","node","isArrayPattern","nonNullElements","elements","filter","element","length","isObjectPattern","properties","firstProperty","value","isAssignmentPattern","left","isRestElement","isIdentifier","argument","identifier","property","objectProperty","pattern","objectPattern","ZERO_REFS","isReferenced","declare","api","opts","assertVersion","targets","supportsObjectAssign","isRequired","compatData","useBuiltIns","loose","Error","ignoreFunctionLength","assumption","objectRestNoSymbols","pureGetters","setSpreadProperties","getExtendsHelper","file","memberExpression","addHelper","hasRestElement","path","foundRestElement","visitRestElements","restElement","stop","hasObjectPatternRestElement","parentPath","visitor","traverse","Expression","parent","key","computed","skip","RestElement","hasSpread","prop","isSpreadElement","extractNormalizedKeys","props","keys","allLiteral","hasTemplateLiteral","push","stringLiteral","name","isTemplateLiteral","cloneNode","isLiteral","String","replaceImpureComputedKeys","scope","impureComputedPropertyDeclarators","propPath","get","isPure","generateUidBasedOnNode","declarator","variableDeclarator","replaceWith","removeUnusedExcludedKeys","bindings","getOuterBindingIdentifierPaths","Object","forEach","bindingName","bindingParentPath","getBinding","references","remove","createObjectRest","objRef","last","assertRestElement","callExpression","objectExpression","keyExpression","arrayExpression","isProgram","block","program","findParent","id","generateUidIdentifier","init","kind","replaceRestElement","paramPath","container","i","uid","declar","variableDeclaration","ensureBlock","unshiftContainer","inherits","syntaxObjectRestSpread","default","Function","params","paramsWithRestElement","Set","idsInRestParams","param","add","getBindingIdentifiers","idInRest","IdentifierHandler","functionScope","has","isReferencedIdentifier","isBindingIdentifier","shouldTransformParam","idx","convertFunctionParams","VariableDeclarator","insertionPath","originalPath","initRef","generateUidIdentifierBasedOnNode","insertBefore","ref","refPropertyPath","unshift","isVariableDeclarator","impureObjRefComputedDeclarators","objectPatternPath","assertIdentifier","insertAfter","registerBinding","ExportNamedDeclaration","declaration","isVariableDeclaration","hasRest","some","specifiers","getOuterBindingIdentifiers","exportSpecifier","exportNamedDeclaration","CatchClause","AssignmentExpression","leftPath","nodes","refName","right","nodeWithoutSpread","expressionStatement","toStatement","assignmentExpression","replaceWithMultiple","ForXStatement","temp","body","isCompletionRecord","buildUndefinedNode","declarations","ArrayPattern","objectPatterns","statementPath","getStatementParent","statementNode","type","ObjectExpression","helper","exp","make","hadProps","obj","arguments"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} |