{"version":3,"sources":["webpack:///./node_modules/@babel/plugin-proposal-object-rest-spread/lib/index.js","webpack:///./node_modules/@babel/plugin-transform-parameters/lib/params.js","webpack:///./node_modules/@babel/plugin-transform-parameters/lib/rest.js","webpack:///./node_modules/@babel/compat-data/corejs2-built-ins.js","webpack:///./node_modules/@babel/plugin-transform-parameters/lib/index.js","webpack:///./node_modules/@babel/plugin-transform-parameters/lib/shadow-utils.js","webpack:///./node_modules/@babel/plugin-syntax-object-rest-spread/lib/index.js"],"names":["Object","defineProperty","exports","value","helperPluginUtils","syntaxObjectRestSpread","core","pluginTransformParameters","helperCompilationTargets","compatData","_interopDefaultLegacy","e","compatData__default","isObjectProperty","isObjectProperty$1","isArrayPattern","isObjectPattern","isAssignmentPattern","isAssignmentPattern$1","isRestElement","isIdentifier","types","shouldStoreRHSInTemporaryVariable","node","nonNullElements","elements","filter","element","length","properties","firstProperty","left","argument","identifier","property","objectProperty","pattern","objectPattern","ZERO_REFS","isReferenced","index","declare","api","opts","_api$assumption","_api$assumption2","_api$assumption3","_api$assumption4","assertVersion","targets","supportsObjectAssign","isRequired","useBuiltIns","loose","Error","ignoreFunctionLength","assumption","objectRestNoSymbols","pureGetters","setSpreadProperties","getExtendsHelper","file","memberExpression","addHelper","hasRestElement","path","foundRestElement","visitRestElements","restElement","stop","hasObjectPatternRestElement","parentPath","visitor","traverse","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","forEach","bindingName","bindingParentPath","getBinding","references","remove","createObjectRest","objRef","last","assertRestElement","callExpression","objectExpression","sequenceExpression","keyExpression","arrayExpression","isProgram","block","program","findParent","id","generateUidIdentifier","init","kind","replaceRestElement","paramPath","container","i","uid","declar","variableDeclaration","ensureBlock","unshiftContainer","inherits","default","params","paramsWithRestElement","Set","idsInRestParams","param","add","getBindingIdentifiers","idInRest","IdentifierHandler","functionScope","has","isReferencedIdentifier","isBindingIdentifier","shouldTransformParam","idx","convertFunctionParams","insertionPath","originalPath","initRef","generateUidIdentifierBasedOnNode","insertBefore","ref","refPropertyPath","unshift","isVariableDeclarator","impureObjRefComputedDeclarators","objectPatternPath","assertIdentifier","insertAfter","registerBinding","declaration","isVariableDeclaration","hasRest","some","specifiers","getOuterBindingIdentifiers","exportSpecifier","exportNamedDeclaration","leftPath","nodes","refName","right","nodeWithoutSpread","expressionStatement","assignmentExpression","replaceWithMultiple","declarations","body","temp","isCompletionRecord","buildUndefinedNode","objectPatterns","statementPath","getStatementParent","statementNode","type","helper","_unused","this","exp","make","hadProps","obj","arguments","_core","_shadowUtils","buildDefaultParam","template","statement","buildLooseDefaultParam","buildLooseDestructuredDefaultParam","buildSafeArgumentsAccess","isSimpleParameterList","every","shadowedParams","collectShadowedParamsNames","state","needsOuterBinding","size","iifeVisitor","firstOptionalIndex","transformedRestNodes","paramIsAssignmentPattern","isMethod","undefinedNode","ASSIGNMENT_IDENTIFIER","DEFAULT_VALUE","UNDEFINED","paramName","PARAMETER_NAME","defNode","VARIABLE_NAME","ARGUMENT_KEY","numericLiteral","typeAnnotation","transformedNode","slice","async","generator","buildScopeIIFE","set","blockStatement","bodyPath","arrowPath","arrowFunctionToExpression","ast","convertFunctionRest","buildRest","restIndex","expression","restIndexImpure","restLength","referencesRest","bindingIdentifierEquals","outerBinding","memberExpressionOptimisationVisitor","isTypeCastExpression","oldNoOptimise","noOptimise","deopted","listKey","offset","isMemberExpression","object","grandparentPath","argsOptEligible","isAssignmentExpression","isLVal","isForXStatement","isUpdateExpression","isUnaryExpression","operator","isCallExpression","isNewExpression","callee","isBaseType","candidates","cause","call","getParamsCount","count","optimiseIndexGetter","argsId","offsetLiteral","isNumericLiteral","binaryExpression","ARGUMENTS","OFFSET","INDEX","replacedParentPath","offsetTestPath","valRes","evaluate","confident","REF","optimiseLengthGetter","restPath","needsIIFE","rest","pop","isPattern","rename","paramsCount","argumentsNode","getBindingIdentifier","clonedArgsId","map","start","len","arrKey","arrLen","conditionalExpression","loop","ARRAY_KEY","ARRAY_LEN","START","ARRAY","KEY","LEN","target","getEarliestCommonAncestorFrom","isLoop","isFunction","module","enumerable","_params","_helperPluginUtils","_rest","_default","options","noNewArrows","isArrowFunctionExpression","allowInsertArrowWithRest","isFunctionExpression","convertedRest","convertedParams","crawl","hasOwnBinding","_functionScope$bindin","constantViolations","redeclarator","isFor","args","returnStatement","arrowFunctionExpression","parserOpts","plugins"],"mappings":"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","file":"js/chunk-59218be0.f355adac.js","sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar helperPluginUtils = require('@babel/helper-plugin-utils');\nvar syntaxObjectRestSpread = require('@babel/plugin-syntax-object-rest-spread');\nvar core = require('@babel/core');\nvar pluginTransformParameters = require('@babel/plugin-transform-parameters');\nvar helperCompilationTargets = require('@babel/helper-compilation-targets');\nvar compatData = require('@babel/compat-data/corejs2-built-ins');\n\nfunction _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\nvar compatData__default = /*#__PURE__*/_interopDefaultLegacy(compatData);\n\nconst {\n  isObjectProperty: isObjectProperty$1,\n  isArrayPattern,\n  isObjectPattern,\n  isAssignmentPattern: isAssignmentPattern$1,\n  isRestElement,\n  isIdentifier\n} = core.types;\nfunction shouldStoreRHSInTemporaryVariable(node) {\n  if (isArrayPattern(node)) {\n    const nonNullElements = node.elements.filter(element => element !== null);\n    if (nonNullElements.length > 1) return true;else return shouldStoreRHSInTemporaryVariable(nonNullElements[0]);\n  } else if (isObjectPattern(node)) {\n    const {\n      properties\n    } = node;\n    if (properties.length > 1) return true;else if (properties.length === 0) return false;else {\n      const firstProperty = properties[0];\n      if (isObjectProperty$1(firstProperty)) {\n        return shouldStoreRHSInTemporaryVariable(firstProperty.value);\n      } else {\n        return shouldStoreRHSInTemporaryVariable(firstProperty);\n      }\n    }\n  } else if (isAssignmentPattern$1(node)) {\n    return shouldStoreRHSInTemporaryVariable(node.left);\n  } else if (isRestElement(node)) {\n    if (isIdentifier(node.argument)) return true;\n    return shouldStoreRHSInTemporaryVariable(node.argument);\n  } else {\n    return false;\n  }\n}\n\nconst {\n  isAssignmentPattern,\n  isObjectProperty\n} = core.types;\n{\n  const node = core.types.identifier(\"a\");\n  const property = core.types.objectProperty(core.types.identifier(\"key\"), node);\n  const pattern = core.types.objectPattern([property]);\n\n  var ZERO_REFS = core.types.isReferenced(node, property, pattern) ? 1 : 0;\n}\nvar index = helperPluginUtils.declare((api, opts) => {\n  var _api$assumption, _api$assumption2, _api$assumption3, _api$assumption4;\n  api.assertVersion(7);\n  const targets = api.targets();\n  const supportsObjectAssign = !helperCompilationTargets.isRequired(\"es6.object.assign\", targets, {\n    compatData: compatData__default[\"default\"]\n  });\n  const {\n    useBuiltIns = supportsObjectAssign,\n    loose = false\n  } = opts;\n  if (typeof loose !== \"boolean\") {\n    throw new Error(\".loose must be a boolean, or undefined\");\n  }\n  const ignoreFunctionLength = (_api$assumption = api.assumption(\"ignoreFunctionLength\")) != null ? _api$assumption : loose;\n  const objectRestNoSymbols = (_api$assumption2 = api.assumption(\"objectRestNoSymbols\")) != null ? _api$assumption2 : loose;\n  const pureGetters = (_api$assumption3 = api.assumption(\"pureGetters\")) != null ? _api$assumption3 : loose;\n  const setSpreadProperties = (_api$assumption4 = api.assumption(\"setSpreadProperties\")) != null ? _api$assumption4 : loose;\n  function getExtendsHelper(file) {\n    return useBuiltIns ? core.types.memberExpression(core.types.identifier(\"Object\"), core.types.identifier(\"assign\")) : file.addHelper(\"extends\");\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  function hasObjectPatternRestElement(path) {\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  function visitRestElements(path, visitor) {\n    path.traverse({\n      Expression(path) {\n        const {\n          parent,\n          key\n        } = path;\n        if (isAssignmentPattern(parent) && key === \"right\" || isObjectProperty(parent) && parent.computed && key === \"key\") {\n          path.skip();\n        }\n      },\n      RestElement: visitor\n    });\n  }\n  function hasSpread(node) {\n    for (const prop of node.properties) {\n      if (core.types.isSpreadElement(prop)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  function extractNormalizedKeys(node) {\n    const props = node.properties;\n    const keys = [];\n    let allLiteral = true;\n    let hasTemplateLiteral = false;\n    for (const prop of props) {\n      if (core.types.isIdentifier(prop.key) && !prop.computed) {\n        keys.push(core.types.stringLiteral(prop.key.name));\n      } else if (core.types.isTemplateLiteral(prop.key)) {\n        keys.push(core.types.cloneNode(prop.key));\n        hasTemplateLiteral = true;\n      } else if (core.types.isLiteral(prop.key)) {\n        keys.push(core.types.stringLiteral(String(\n        prop.key.value)));\n      } else {\n        keys.push(core.types.cloneNode(prop.key));\n        allLiteral = false;\n      }\n    }\n    return {\n      keys,\n      allLiteral,\n      hasTemplateLiteral\n    };\n  }\n\n  function replaceImpureComputedKeys(properties, scope) {\n    const impureComputedPropertyDeclarators = [];\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 = core.types.variableDeclarator(core.types.identifier(name), key.node);\n        impureComputedPropertyDeclarators.push(declarator);\n        key.replaceWith(core.types.identifier(name));\n      }\n    }\n    return impureComputedPropertyDeclarators;\n  }\n  function removeUnusedExcludedKeys(path) {\n    const bindings = path.getOuterBindingIdentifierPaths();\n    Object.keys(bindings).forEach(bindingName => {\n      const bindingParentPath = bindings[bindingName].parentPath;\n      if (path.scope.getBinding(bindingName).references > ZERO_REFS || !bindingParentPath.isObjectProperty()) {\n        return;\n      }\n      bindingParentPath.remove();\n    });\n  }\n\n  function createObjectRest(path, file, objRef) {\n    const props = path.get(\"properties\");\n    const last = props[props.length - 1];\n    core.types.assertRestElement(last.node);\n    const restElement = core.types.cloneNode(last.node);\n    last.remove();\n    const impureComputedPropertyDeclarators = replaceImpureComputedKeys(path.get(\"properties\"), path.scope);\n    const {\n      keys,\n      allLiteral,\n      hasTemplateLiteral\n    } = extractNormalizedKeys(path.node);\n    if (keys.length === 0) {\n      return [impureComputedPropertyDeclarators, restElement.argument, core.types.callExpression(getExtendsHelper(file), [core.types.objectExpression([]), core.types.sequenceExpression([core.types.callExpression(file.addHelper(\"objectDestructuringEmpty\"), [core.types.cloneNode(objRef)]), core.types.cloneNode(objRef)])])];\n    }\n    let keyExpression;\n    if (!allLiteral) {\n      keyExpression = core.types.callExpression(core.types.memberExpression(core.types.arrayExpression(keys), core.types.identifier(\"map\")), [file.addHelper(\"toPropertyKey\")]);\n    } else {\n      keyExpression = core.types.arrayExpression(keys);\n      if (!hasTemplateLiteral && !core.types.isProgram(path.scope.block)) {\n        const program = path.findParent(path => path.isProgram());\n        const id = path.scope.generateUidIdentifier(\"excluded\");\n        program.scope.push({\n          id,\n          init: keyExpression,\n          kind: \"const\"\n        });\n        keyExpression = core.types.cloneNode(id);\n      }\n    }\n    return [impureComputedPropertyDeclarators, restElement.argument, core.types.callExpression(file.addHelper(`objectWithoutProperties${objectRestNoSymbols ? \"Loose\" : \"\"}`), [core.types.cloneNode(objRef), keyExpression])];\n  }\n  function replaceRestElement(parentPath, paramPath, container) {\n    if (paramPath.isAssignmentPattern()) {\n      replaceRestElement(parentPath, paramPath.get(\"left\"), container);\n      return;\n    }\n    if (paramPath.isArrayPattern() && hasRestElement(paramPath)) {\n      const elements = paramPath.get(\"elements\");\n      for (let i = 0; i < elements.length; i++) {\n        replaceRestElement(parentPath, elements[i], container);\n      }\n    }\n    if (paramPath.isObjectPattern() && hasRestElement(paramPath)) {\n      const uid = parentPath.scope.generateUidIdentifier(\"ref\");\n      const declar = core.types.variableDeclaration(\"let\", [core.types.variableDeclarator(paramPath.node, uid)]);\n      if (container) {\n        container.push(declar);\n      } else {\n        parentPath.ensureBlock();\n        parentPath.get(\"body\").unshiftContainer(\"body\", declar);\n      }\n      paramPath.replaceWith(core.types.cloneNode(uid));\n    }\n  }\n  return {\n    name: \"proposal-object-rest-spread\",\n    inherits: syntaxObjectRestSpread.default,\n    visitor: {\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        let idInRest = false;\n        const IdentifierHandler = function (path, functionScope) {\n          const name = path.node.name;\n          if (path.scope.getBinding(name) === functionScope.getBinding(name) && idsInRestParams.has(name)) {\n            idInRest = true;\n            path.stop();\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(param, path.scope);\n            } else {\n              param.traverse({\n                \"Scope|TypeAnnotation|TSTypeAnnotation\": path => path.skip(),\n                \"ReferencedIdentifier|BindingIdentifier\": IdentifierHandler\n              }, path.scope);\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 => idx >= i - 1 || paramsWithRestElement.has(idx);\n          pluginTransformParameters.convertFunctionParams(path, ignoreFunctionLength, shouldTransformParam, replaceRestElement);\n        }\n      },\n      VariableDeclarator(path, file) {\n        if (!path.get(\"id\").isObjectPattern()) {\n          return;\n        }\n        let insertionPath = path;\n        const originalPath = path;\n        visitRestElements(path.get(\"id\"), path => {\n          if (!path.parentPath.isObjectPattern()) {\n            return;\n          }\n          if (\n          shouldStoreRHSInTemporaryVariable(originalPath.node.id) && !core.types.isIdentifier(originalPath.node.init)) {\n            const initRef = path.scope.generateUidIdentifierBasedOnNode(originalPath.node.init, \"ref\");\n            originalPath.insertBefore(core.types.variableDeclarator(initRef, originalPath.node.init));\n            originalPath.replaceWith(core.types.variableDeclarator(originalPath.node.id, core.types.cloneNode(initRef)));\n            return;\n          }\n          let ref = originalPath.node.init;\n          const refPropertyPath = [];\n          let kind;\n          path.findParent(path => {\n            if (path.isObjectProperty()) {\n              refPropertyPath.unshift(path);\n            } else if (path.isVariableDeclarator()) {\n              kind = path.parentPath.node.kind;\n              return true;\n            }\n          });\n          const impureObjRefComputedDeclarators = replaceImpureComputedKeys(refPropertyPath, path.scope);\n          refPropertyPath.forEach(prop => {\n            const {\n              node\n            } = prop;\n            ref = core.types.memberExpression(ref, core.types.cloneNode(node.key), node.computed || core.types.isLiteral(node.key));\n          });\n\n          const objectPatternPath = path.findParent(path => path.isObjectPattern());\n          const [impureComputedPropertyDeclarators, argument, callExpression] = createObjectRest(objectPatternPath, file, ref);\n          if (pureGetters) {\n            removeUnusedExcludedKeys(objectPatternPath);\n          }\n          core.types.assertIdentifier(argument);\n          insertionPath.insertBefore(impureComputedPropertyDeclarators);\n          insertionPath.insertBefore(impureObjRefComputedDeclarators);\n          insertionPath = insertionPath.insertAfter(core.types.variableDeclarator(argument, callExpression))[0];\n          path.scope.registerBinding(kind, insertionPath);\n          if (objectPatternPath.node.properties.length === 0) {\n            objectPatternPath.findParent(path => path.isObjectProperty() || path.isVariableDeclarator()).remove();\n          }\n        });\n      },\n      ExportNamedDeclaration(path) {\n        const declaration = path.get(\"declaration\");\n        if (!declaration.isVariableDeclaration()) return;\n        const hasRest = declaration.get(\"declarations\").some(path => hasObjectPatternRestElement(path.get(\"id\")));\n        if (!hasRest) return;\n        const specifiers = [];\n        for (const name of Object.keys(path.getOuterBindingIdentifiers(true))) {\n          specifiers.push(core.types.exportSpecifier(core.types.identifier(name), core.types.identifier(name)));\n        }\n\n        path.replaceWith(declaration.node);\n        path.insertAfter(core.types.exportNamedDeclaration(null, specifiers));\n      },\n      CatchClause(path) {\n        const paramPath = path.get(\"param\");\n        replaceRestElement(path, paramPath);\n      },\n      AssignmentExpression(path, file) {\n        const leftPath = path.get(\"left\");\n        if (leftPath.isObjectPattern() && hasRestElement(leftPath)) {\n          const nodes = [];\n          const refName = path.scope.generateUidBasedOnNode(path.node.right, \"ref\");\n          nodes.push(core.types.variableDeclaration(\"var\", [core.types.variableDeclarator(core.types.identifier(refName), path.node.right)]));\n          const [impureComputedPropertyDeclarators, argument, callExpression] = createObjectRest(leftPath, file, core.types.identifier(refName));\n          if (impureComputedPropertyDeclarators.length > 0) {\n            nodes.push(core.types.variableDeclaration(\"var\", impureComputedPropertyDeclarators));\n          }\n          const nodeWithoutSpread = core.types.cloneNode(path.node);\n          nodeWithoutSpread.right = core.types.identifier(refName);\n          nodes.push(core.types.expressionStatement(nodeWithoutSpread));\n          nodes.push(core.types.expressionStatement(core.types.assignmentExpression(\"=\", argument, callExpression)));\n          nodes.push(core.types.expressionStatement(core.types.identifier(refName)));\n          path.replaceWithMultiple(nodes);\n        }\n      },\n      ForXStatement(path) {\n        const {\n          node,\n          scope\n        } = path;\n        const leftPath = path.get(\"left\");\n        const left = node.left;\n        if (!hasObjectPatternRestElement(leftPath)) {\n          return;\n        }\n        if (!core.types.isVariableDeclaration(left)) {\n          const temp = scope.generateUidIdentifier(\"ref\");\n          node.left = core.types.variableDeclaration(\"var\", [core.types.variableDeclarator(temp)]);\n          path.ensureBlock();\n          const body = path.node.body;\n          if (body.body.length === 0 && path.isCompletionRecord()) {\n            body.body.unshift(core.types.expressionStatement(scope.buildUndefinedNode()));\n          }\n          body.body.unshift(core.types.expressionStatement(core.types.assignmentExpression(\"=\", left, core.types.cloneNode(temp))));\n        } else {\n          const pattern = left.declarations[0].id;\n          const key = scope.generateUidIdentifier(\"ref\");\n          node.left = core.types.variableDeclaration(left.kind, [core.types.variableDeclarator(key, null)]);\n          path.ensureBlock();\n          const body = node.body;\n          body.body.unshift(core.types.variableDeclaration(node.left.kind, [core.types.variableDeclarator(pattern, core.types.cloneNode(key))]));\n        }\n      },\n      ArrayPattern(path) {\n        const objectPatterns = [];\n        visitRestElements(path, path => {\n          if (!path.parentPath.isObjectPattern()) {\n            return;\n          }\n          const objectPattern = path.parentPath;\n          const uid = path.scope.generateUidIdentifier(\"ref\");\n          objectPatterns.push(core.types.variableDeclarator(objectPattern.node, uid));\n          objectPattern.replaceWith(core.types.cloneNode(uid));\n          path.skip();\n        });\n        if (objectPatterns.length > 0) {\n          const statementPath = path.getStatementParent();\n          const statementNode = statementPath.node;\n          const kind = statementNode.type === \"VariableDeclaration\" ? statementNode.kind : \"var\";\n          statementPath.insertAfter(core.types.variableDeclaration(kind, objectPatterns));\n        }\n      },\n      ObjectExpression(path, file) {\n        if (!hasSpread(path.node)) return;\n        let helper;\n        if (setSpreadProperties) {\n          helper = getExtendsHelper(file);\n        } else {\n          try {\n            helper = file.addHelper(\"objectSpread2\");\n          } catch (_unused) {\n            this.file.declarations[\"objectSpread2\"] = null;\n\n            helper = file.addHelper(\"objectSpread\");\n          }\n        }\n        let exp = null;\n        let props = [];\n        function make() {\n          const hadProps = props.length > 0;\n          const obj = core.types.objectExpression(props);\n          props = [];\n          if (!exp) {\n            exp = core.types.callExpression(helper, [obj]);\n            return;\n          }\n\n          if (pureGetters) {\n            if (hadProps) {\n              exp.arguments.push(obj);\n            }\n            return;\n          }\n          exp = core.types.callExpression(core.types.cloneNode(helper), [exp,\n          ...(hadProps ? [core.types.objectExpression([]), obj] : [])]);\n        }\n        for (const prop of path.node.properties) {\n          if (core.types.isSpreadElement(prop)) {\n            make();\n            exp.arguments.push(prop.argument);\n          } else {\n            props.push(prop);\n          }\n        }\n        if (props.length) make();\n        path.replaceWith(exp);\n      }\n    }\n  };\n});\n\nexports[\"default\"] = index;\n//# sourceMappingURL=index.js.map\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = convertFunctionParams;\nvar _core = require(\"@babel/core\");\nvar _shadowUtils = require(\"./shadow-utils\");\nconst buildDefaultParam = _core.template.statement(`\n  let VARIABLE_NAME =\n    arguments.length > ARGUMENT_KEY && arguments[ARGUMENT_KEY] !== undefined ?\n      arguments[ARGUMENT_KEY]\n    :\n      DEFAULT_VALUE;\n`);\nconst buildLooseDefaultParam = _core.template.statement(`\n  if (ASSIGNMENT_IDENTIFIER === UNDEFINED) {\n    ASSIGNMENT_IDENTIFIER = DEFAULT_VALUE;\n  }\n`);\nconst buildLooseDestructuredDefaultParam = _core.template.statement(`\n  let ASSIGNMENT_IDENTIFIER = PARAMETER_NAME === UNDEFINED ? DEFAULT_VALUE : PARAMETER_NAME ;\n`);\nconst buildSafeArgumentsAccess = _core.template.statement(`\n  let $0 = arguments.length > $1 ? arguments[$1] : undefined;\n`);\n\nfunction convertFunctionParams(path, ignoreFunctionLength, shouldTransformParam, replaceRestElement) {\n  const params = path.get(\"params\");\n  const isSimpleParameterList = params.every(param => param.isIdentifier());\n  if (isSimpleParameterList) return false;\n  const {\n    node,\n    scope\n  } = path;\n  const body = [];\n  const shadowedParams = new Set();\n  for (const param of params) {\n    (0, _shadowUtils.collectShadowedParamsNames)(param, scope, shadowedParams);\n  }\n  const state = {\n    needsOuterBinding: false,\n    scope\n  };\n  if (shadowedParams.size === 0) {\n    for (const param of params) {\n      if (!param.isIdentifier()) param.traverse(_shadowUtils.iifeVisitor, state);\n      if (state.needsOuterBinding) break;\n    }\n  }\n  let firstOptionalIndex = null;\n  for (let i = 0; i < params.length; i++) {\n    const param = params[i];\n    if (shouldTransformParam && !shouldTransformParam(i)) {\n      continue;\n    }\n    const transformedRestNodes = [];\n    if (replaceRestElement) {\n      replaceRestElement(path, param, transformedRestNodes);\n    }\n    const paramIsAssignmentPattern = param.isAssignmentPattern();\n    if (paramIsAssignmentPattern && (ignoreFunctionLength || _core.types.isMethod(node, {\n      kind: \"set\"\n    }))) {\n      const left = param.get(\"left\");\n      const right = param.get(\"right\");\n      const undefinedNode = scope.buildUndefinedNode();\n      if (left.isIdentifier()) {\n        body.push(buildLooseDefaultParam({\n          ASSIGNMENT_IDENTIFIER: _core.types.cloneNode(left.node),\n          DEFAULT_VALUE: right.node,\n          UNDEFINED: undefinedNode\n        }));\n        param.replaceWith(left.node);\n      } else if (left.isObjectPattern() || left.isArrayPattern()) {\n        const paramName = scope.generateUidIdentifier();\n        body.push(buildLooseDestructuredDefaultParam({\n          ASSIGNMENT_IDENTIFIER: left.node,\n          DEFAULT_VALUE: right.node,\n          PARAMETER_NAME: _core.types.cloneNode(paramName),\n          UNDEFINED: undefinedNode\n        }));\n        param.replaceWith(paramName);\n      }\n    } else if (paramIsAssignmentPattern) {\n      if (firstOptionalIndex === null) firstOptionalIndex = i;\n      const left = param.get(\"left\");\n      const right = param.get(\"right\");\n      const defNode = buildDefaultParam({\n        VARIABLE_NAME: left.node,\n        DEFAULT_VALUE: right.node,\n        ARGUMENT_KEY: _core.types.numericLiteral(i)\n      });\n      body.push(defNode);\n    } else if (firstOptionalIndex !== null) {\n      const defNode = buildSafeArgumentsAccess([param.node, _core.types.numericLiteral(i)]);\n      body.push(defNode);\n    } else if (param.isObjectPattern() || param.isArrayPattern()) {\n      const uid = path.scope.generateUidIdentifier(\"ref\");\n      uid.typeAnnotation = param.node.typeAnnotation;\n      const defNode = _core.types.variableDeclaration(\"let\", [_core.types.variableDeclarator(param.node, uid)]);\n      body.push(defNode);\n      param.replaceWith(_core.types.cloneNode(uid));\n    }\n    if (transformedRestNodes) {\n      for (const transformedNode of transformedRestNodes) {\n        body.push(transformedNode);\n      }\n    }\n  }\n\n  if (firstOptionalIndex !== null) {\n    node.params = node.params.slice(0, firstOptionalIndex);\n  }\n\n  path.ensureBlock();\n  const {\n    async,\n    generator\n  } = node;\n  if (generator || state.needsOuterBinding || shadowedParams.size > 0) {\n    body.push((0, _shadowUtils.buildScopeIIFE)(shadowedParams, path.node.body));\n    path.set(\"body\", _core.types.blockStatement(body));\n\n    const bodyPath = path.get(\"body.body\");\n    const arrowPath = bodyPath[bodyPath.length - 1].get(\"argument.callee\");\n\n    arrowPath.arrowFunctionToExpression();\n    arrowPath.node.generator = generator;\n    arrowPath.node.async = async;\n    node.generator = false;\n    node.async = false;\n    if (async) {\n      path.node.body = _core.template.statement.ast`{\n        try {\n          ${path.node.body.body}\n        } catch (e) {\n          return Promise.reject(e);\n        }\n      }`;\n    }\n  } else {\n    path.get(\"body\").unshiftContainer(\"body\", body);\n  }\n  return true;\n}\n\n//# sourceMappingURL=params.js.map\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = convertFunctionRest;\nvar _core = require(\"@babel/core\");\nvar _shadowUtils = require(\"./shadow-utils\");\nconst buildRest = _core.template.statement(`\n  for (var LEN = ARGUMENTS.length,\n           ARRAY = new Array(ARRAY_LEN),\n           KEY = START;\n       KEY < LEN;\n       KEY++) {\n    ARRAY[ARRAY_KEY] = ARGUMENTS[KEY];\n  }\n`);\nconst restIndex = _core.template.expression(`\n  (INDEX < OFFSET || ARGUMENTS.length <= INDEX) ? undefined : ARGUMENTS[INDEX]\n`);\nconst restIndexImpure = _core.template.expression(`\n  REF = INDEX, (REF < OFFSET || ARGUMENTS.length <= REF) ? undefined : ARGUMENTS[REF]\n`);\nconst restLength = _core.template.expression(`\n  ARGUMENTS.length <= OFFSET ? 0 : ARGUMENTS.length - OFFSET\n`);\nfunction referencesRest(path, state) {\n  if (path.node.name === state.name) {\n    return path.scope.bindingIdentifierEquals(state.name, state.outerBinding);\n  }\n  return false;\n}\nconst memberExpressionOptimisationVisitor = {\n  Scope(path, state) {\n    if (!path.scope.bindingIdentifierEquals(state.name, state.outerBinding)) {\n      path.skip();\n    }\n  },\n  Flow(path) {\n    if (path.isTypeCastExpression()) return;\n    path.skip();\n  },\n  Function(path, state) {\n    const oldNoOptimise = state.noOptimise;\n    state.noOptimise = true;\n    path.traverse(memberExpressionOptimisationVisitor, state);\n    state.noOptimise = oldNoOptimise;\n\n    path.skip();\n  },\n  ReferencedIdentifier(path, state) {\n    const {\n      node\n    } = path;\n\n    if (node.name === \"arguments\") {\n      state.deopted = true;\n    }\n\n    if (!referencesRest(path, state)) return;\n    if (state.noOptimise) {\n      state.deopted = true;\n    } else {\n      const {\n        parentPath\n      } = path;\n\n      if (parentPath.listKey === \"params\" && parentPath.key < state.offset) {\n        return;\n      }\n\n      if (parentPath.isMemberExpression({\n        object: node\n      })) {\n        const grandparentPath = parentPath.parentPath;\n        const argsOptEligible = !state.deopted && !(\n\n        grandparentPath.isAssignmentExpression() && parentPath.node === grandparentPath.node.left ||\n        grandparentPath.isLVal() ||\n        grandparentPath.isForXStatement() ||\n        grandparentPath.isUpdateExpression() ||\n        grandparentPath.isUnaryExpression({\n          operator: \"delete\"\n        }) ||\n        (grandparentPath.isCallExpression() || grandparentPath.isNewExpression()) && parentPath.node === grandparentPath.node.callee);\n        if (argsOptEligible) {\n          if (parentPath.node.computed) {\n            if (parentPath.get(\"property\").isBaseType(\"number\")) {\n              state.candidates.push({\n                cause: \"indexGetter\",\n                path\n              });\n              return;\n            }\n          } else if (\n          parentPath.node.property.name === \"length\") {\n            state.candidates.push({\n              cause: \"lengthGetter\",\n              path\n            });\n            return;\n          }\n        }\n      }\n\n      if (state.offset === 0 && parentPath.isSpreadElement()) {\n        const call = parentPath.parentPath;\n        if (call.isCallExpression() && call.node.arguments.length === 1) {\n          state.candidates.push({\n            cause: \"argSpread\",\n            path\n          });\n          return;\n        }\n      }\n      state.references.push(path);\n    }\n  },\n\n  BindingIdentifier(path, state) {\n    if (referencesRest(path, state)) {\n      state.deopted = true;\n    }\n  }\n};\nfunction getParamsCount(node) {\n  let count = node.params.length;\n  if (count > 0 && _core.types.isIdentifier(node.params[0], {\n    name: \"this\"\n  })) {\n    count -= 1;\n  }\n  return count;\n}\nfunction hasRest(node) {\n  const length = node.params.length;\n  return length > 0 && _core.types.isRestElement(node.params[length - 1]);\n}\nfunction optimiseIndexGetter(path, argsId, offset) {\n  const offsetLiteral = _core.types.numericLiteral(offset);\n  let index;\n  const parent = path.parent;\n  if (_core.types.isNumericLiteral(parent.property)) {\n    index = _core.types.numericLiteral(parent.property.value + offset);\n  } else if (offset === 0) {\n    index = parent.property;\n  } else {\n    index = _core.types.binaryExpression(\"+\", parent.property, _core.types.cloneNode(offsetLiteral));\n  }\n  const {\n    scope,\n    parentPath\n  } = path;\n  if (!scope.isPure(index)) {\n    const temp = scope.generateUidIdentifierBasedOnNode(index);\n    scope.push({\n      id: temp,\n      kind: \"var\"\n    });\n    parentPath.replaceWith(restIndexImpure({\n      ARGUMENTS: argsId,\n      OFFSET: offsetLiteral,\n      INDEX: index,\n      REF: _core.types.cloneNode(temp)\n    }));\n  } else {\n    parentPath.replaceWith(restIndex({\n      ARGUMENTS: argsId,\n      OFFSET: offsetLiteral,\n      INDEX: index\n    }));\n    const replacedParentPath = parentPath;\n\n    const offsetTestPath = replacedParentPath.get(\"test\");\n    const valRes = offsetTestPath.get(\"left\").evaluate();\n    if (valRes.confident) {\n      if (valRes.value === true) {\n        replacedParentPath.replaceWith(scope.buildUndefinedNode());\n      } else {\n        offsetTestPath.replaceWith(offsetTestPath.get(\"right\"));\n      }\n    }\n  }\n}\nfunction optimiseLengthGetter(path, argsId, offset) {\n  if (offset) {\n    path.parentPath.replaceWith(restLength({\n      ARGUMENTS: argsId,\n      OFFSET: _core.types.numericLiteral(offset)\n    }));\n  } else {\n    path.replaceWith(argsId);\n  }\n}\nfunction convertFunctionRest(path) {\n  const {\n    node,\n    scope\n  } = path;\n  if (!hasRest(node)) return false;\n  const restPath = path.get(`params.${node.params.length - 1}.argument`);\n  if (!restPath.isIdentifier()) {\n    const shadowedParams = new Set();\n    (0, _shadowUtils.collectShadowedParamsNames)(restPath, path.scope, shadowedParams);\n    let needsIIFE = shadowedParams.size > 0;\n    if (!needsIIFE) {\n      const state = {\n        needsOuterBinding: false,\n        scope\n      };\n      restPath.traverse(_shadowUtils.iifeVisitor, state);\n      needsIIFE = state.needsOuterBinding;\n    }\n    if (needsIIFE) {\n      path.ensureBlock();\n      path.set(\"body\", _core.types.blockStatement([(0, _shadowUtils.buildScopeIIFE)(shadowedParams, path.node.body)]));\n    }\n  }\n  let rest = restPath.node;\n  node.params.pop();\n\n  if (_core.types.isPattern(rest)) {\n    const pattern = rest;\n    rest = scope.generateUidIdentifier(\"ref\");\n    const declar = _core.types.variableDeclaration(\"let\", [_core.types.variableDeclarator(pattern, rest)]);\n    path.ensureBlock();\n    node.body.body.unshift(declar);\n  } else if (rest.name === \"arguments\") {\n    scope.rename(rest.name);\n  }\n  const argsId = _core.types.identifier(\"arguments\");\n  const paramsCount = getParamsCount(node);\n\n  const state = {\n    references: [],\n    offset: paramsCount,\n    argumentsNode: argsId,\n    outerBinding: scope.getBindingIdentifier(rest.name),\n    candidates: [],\n    name: rest.name,\n    deopted: false\n  };\n  path.traverse(memberExpressionOptimisationVisitor, state);\n\n  if (!state.deopted && !state.references.length) {\n    for (const {\n      path,\n      cause\n    } of state.candidates) {\n      const clonedArgsId = _core.types.cloneNode(argsId);\n      switch (cause) {\n        case \"indexGetter\":\n          optimiseIndexGetter(path, clonedArgsId, state.offset);\n          break;\n        case \"lengthGetter\":\n          optimiseLengthGetter(path, clonedArgsId, state.offset);\n          break;\n        default:\n          path.replaceWith(clonedArgsId);\n      }\n    }\n    return true;\n  }\n  state.references.push(...state.candidates.map(({\n    path\n  }) => path));\n  const start = _core.types.numericLiteral(paramsCount);\n  const key = scope.generateUidIdentifier(\"key\");\n  const len = scope.generateUidIdentifier(\"len\");\n  let arrKey, arrLen;\n  if (paramsCount) {\n    arrKey = _core.types.binaryExpression(\"-\", _core.types.cloneNode(key), _core.types.cloneNode(start));\n\n    arrLen = _core.types.conditionalExpression(_core.types.binaryExpression(\">\", _core.types.cloneNode(len), _core.types.cloneNode(start)), _core.types.binaryExpression(\"-\", _core.types.cloneNode(len), _core.types.cloneNode(start)), _core.types.numericLiteral(0));\n  } else {\n    arrKey = _core.types.identifier(key.name);\n    arrLen = _core.types.identifier(len.name);\n  }\n  const loop = buildRest({\n    ARGUMENTS: argsId,\n    ARRAY_KEY: arrKey,\n    ARRAY_LEN: arrLen,\n    START: start,\n    ARRAY: rest,\n    KEY: key,\n    LEN: len\n  });\n  if (state.deopted) {\n    node.body.body.unshift(loop);\n  } else {\n    let target = path.getEarliestCommonAncestorFrom(state.references).getStatementParent();\n\n    target.findParent(path => {\n      if (path.isLoop()) {\n        target = path;\n      } else {\n        return path.isFunction();\n      }\n    });\n    target.insertBefore(loop);\n  }\n  return true;\n}\n\n//# sourceMappingURL=rest.js.map\n","module.exports = require(\"./data/corejs2-built-ins.json\");\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nObject.defineProperty(exports, \"convertFunctionParams\", {\n  enumerable: true,\n  get: function () {\n    return _params.default;\n  }\n});\nexports.default = void 0;\nvar _helperPluginUtils = require(\"@babel/helper-plugin-utils\");\nvar _params = require(\"./params\");\nvar _rest = require(\"./rest\");\nvar _default = (0, _helperPluginUtils.declare)((api, options) => {\n  var _api$assumption, _api$assumption2;\n  api.assertVersion(7);\n  const ignoreFunctionLength = (_api$assumption = api.assumption(\"ignoreFunctionLength\")) != null ? _api$assumption : options.loose;\n  const noNewArrows = (_api$assumption2 = api.assumption(\"noNewArrows\")) != null ? _api$assumption2 : true;\n  return {\n    name: \"transform-parameters\",\n    visitor: {\n      Function(path) {\n        if (path.isArrowFunctionExpression() && path.get(\"params\").some(param => param.isRestElement() || param.isAssignmentPattern())) {\n          path.arrowFunctionToExpression({\n            allowInsertArrowWithRest: false,\n            noNewArrows\n          });\n\n          if (!path.isFunctionExpression()) return;\n        }\n        const convertedRest = (0, _rest.default)(path);\n        const convertedParams = (0, _params.default)(path, ignoreFunctionLength);\n        if (convertedRest || convertedParams) {\n          path.scope.crawl();\n        }\n      }\n    }\n  };\n});\nexports.default = _default;\n\n//# sourceMappingURL=index.js.map\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.buildScopeIIFE = buildScopeIIFE;\nexports.collectShadowedParamsNames = collectShadowedParamsNames;\nexports.iifeVisitor = void 0;\nvar _core = require(\"@babel/core\");\nconst iifeVisitor = {\n  \"ReferencedIdentifier|BindingIdentifier\"(path, state) {\n    const {\n      scope,\n      node\n    } = path;\n    const {\n      name\n    } = node;\n    if (name === \"eval\" || scope.getBinding(name) === state.scope.parent.getBinding(name) && state.scope.hasOwnBinding(name)) {\n      state.needsOuterBinding = true;\n      path.stop();\n    }\n  },\n  \"TypeAnnotation|TSTypeAnnotation|TypeParameterDeclaration|TSTypeParameterDeclaration\": path => path.skip()\n};\nexports.iifeVisitor = iifeVisitor;\nfunction collectShadowedParamsNames(param, functionScope, shadowedParams) {\n  for (const name of Object.keys(param.getBindingIdentifiers())) {\n    var _functionScope$bindin;\n    const constantViolations = (_functionScope$bindin = functionScope.bindings[name]) == null ? void 0 : _functionScope$bindin.constantViolations;\n    if (constantViolations) {\n      for (const redeclarator of constantViolations) {\n        const node = redeclarator.node;\n        switch (node.type) {\n          case \"VariableDeclarator\":\n            {\n              if (node.init === null) {\n                const declaration = redeclarator.parentPath;\n                if (!declaration.parentPath.isFor() || declaration.parentPath.get(\"body\") === declaration) {\n                  redeclarator.remove();\n                  break;\n                }\n              }\n              shadowedParams.add(name);\n              break;\n            }\n          case \"FunctionDeclaration\":\n            shadowedParams.add(name);\n            break;\n        }\n      }\n    }\n  }\n}\nfunction buildScopeIIFE(shadowedParams, body) {\n  const args = [];\n  const params = [];\n  for (const name of shadowedParams) {\n    args.push(_core.types.identifier(name));\n    params.push(_core.types.identifier(name));\n  }\n  return _core.types.returnStatement(_core.types.callExpression(_core.types.arrowFunctionExpression(params, body), args));\n}\n\n//# sourceMappingURL=shadow-utils.js.map\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _helperPluginUtils = require(\"@babel/helper-plugin-utils\");\n\nvar _default = (0, _helperPluginUtils.declare)(api => {\n  api.assertVersion(7);\n  return {\n    name: \"syntax-object-rest-spread\",\n\n    manipulateOptions(opts, parserOpts) {\n      parserOpts.plugins.push(\"objectRestSpread\");\n    }\n\n  };\n});\n\nexports.default = _default;"],"sourceRoot":""}