{"version":3,"sources":["webpack:///./node_modules/babel-plugin-minify-dead-code-elimination/lib/remove-use-strict.js","webpack:///./node_modules/babel-plugin-transform-inline-consecutive-adds/lib/object-collapser.js","webpack:///./node_modules/babel-plugin-minify-guarded-expressions/lib/index.js","webpack:///./node_modules/babel-plugin-minify-mangle-names/lib/counted-set.js","webpack:///./node_modules/lodash/_isStrictComparable.js","webpack:///./node_modules/babel-plugin-minify-constant-folding/lib/index.js","webpack:///./node_modules/babel-plugin-transform-property-literals/lib/escape-string-literal.js","webpack:///./node_modules/babel-plugin-transform-remove-console/lib/index.js","webpack:///./node_modules/babel-plugin-minify-dead-code-elimination/lib/index.js","webpack:///./node_modules/babel-plugin-minify-mangle-names/lib/scope-tracker.js","webpack:///./node_modules/esutils/lib/ast.js","webpack:///./node_modules/babel-plugin-minify-flip-comparisons/lib/index.js","webpack:///./node_modules/babel-plugin-transform-regexp-constructors/lib/index.js","webpack:///./node_modules/lodash/_baseMatchesProperty.js","webpack:///./node_modules/lodash/_stringToPath.js","webpack:///./node_modules/babel-plugin-minify-mangle-names/lib/charset.js","webpack:///./node_modules/babel-plugin-transform-simplify-comparison-operators/lib/index.js","webpack:///./node_modules/babel-plugin-minify-simplify/lib/conditional-expression.js","webpack:///./node_modules/babel-helper-remove-or-void/lib/index.js","webpack:///./node_modules/lodash/_equalByTag.js","webpack:///./node_modules/lodash/_matchesStrictComparable.js","webpack:///./node_modules/lodash/_memoizeCapped.js","webpack:///./node_modules/lodash/_baseForOwn.js","webpack:///./node_modules/babel-plugin-minify-mangle-names/lib/fixup-var-scoping.js","webpack:///./node_modules/lodash/_baseHasIn.js","webpack:///./node_modules/esutils/lib/code.js","webpack:///./node_modules/babel-plugin-minify-simplify/lib/if-statement.js","webpack:///./node_modules/lodash/some.js","webpack:///./node_modules/babel-plugin-transform-merge-sibling-variables/lib/index.js","webpack:///./node_modules/babel-plugin-transform-inline-consecutive-adds/lib/index.js","webpack:///./node_modules/babel-helper-flip-expressions/lib/index.js","webpack:///./node_modules/lodash/_baseSome.js","webpack:///./node_modules/lodash/_getMatchData.js","webpack:///./node_modules/lodash/_arraySome.js","webpack:///./node_modules/babel-plugin-transform-undefined-to-void/lib/index.js","webpack:///./node_modules/lodash/_baseEach.js","webpack:///./node_modules/babel-helper-is-void-0/lib/index.js","webpack:///./node_modules/babel-plugin-minify-simplify/lib/pattern-match.js","webpack:///./node_modules/lodash/isPlainObject.js","webpack:///./node_modules/lodash/_baseMatches.js","webpack:///./node_modules/babel-plugin-minify-simplify/lib/index.js","webpack:///./node_modules/lodash/_baseGet.js","webpack:///./node_modules/babel-plugin-minify-builtins/lib/index.js","webpack:///./node_modules/babel-plugin-minify-mangle-names/lib/bfs-traverse.js","webpack:///./node_modules/esutils/lib/utils.js","webpack:///./node_modules/babel-plugin-minify-simplify/lib/assignment-expression.js","webpack:///./node_modules/lodash/_baseIsEqualDeep.js","webpack:///./node_modules/lodash/_setCacheAdd.js","webpack:///./node_modules/babel-plugin-minify-simplify/lib/helpers.js","webpack:///./node_modules/lodash/hasIn.js","webpack:///./node_modules/babel-plugin-transform-member-expression-literals/lib/index.js","webpack:///./node_modules/babel-plugin-transform-inline-consecutive-adds/lib/array-collapser.js","webpack:///./node_modules/esutils/lib/keyword.js","webpack:///./node_modules/lodash/_createBaseEach.js","webpack:///./node_modules/lodash/_baseIsMatch.js","webpack:///./node_modules/babel-plugin-transform-inline-consecutive-adds/lib/set-collapser.js","webpack:///./node_modules/lodash/get.js","webpack:///./node_modules/babel-plugin-minify-numeric-literals/lib/index.js","webpack:///./node_modules/lodash/_equalArrays.js","webpack:///./node_modules/babel-plugin-minify-infinity/lib/index.js","webpack:///./node_modules/babel-plugin-minify-mangle-names/lib/is-label-identifier.js","webpack:///./node_modules/lodash/_setToArray.js","webpack:///./node_modules/babel-plugin-minify-type-constructors/lib/index.js","webpack:///./node_modules/babel-plugin-transform-inline-consecutive-adds/lib/collapser.js","webpack:///./node_modules/babel-plugin-minify-constant-folding/lib/replacements.js","webpack:///./node_modules/babel-helper-to-multiple-sequence-expressions/lib/index.js","webpack:///./node_modules/babel-plugin-transform-minify-booleans/lib/index.js","webpack:///./node_modules/lodash/_equalObjects.js","webpack:///./node_modules/lodash/_baseIteratee.js","webpack:///./node_modules/lodash/_baseIsEqual.js","webpack:///./node_modules/babel-helper-evaluate-path/lib/index.js","webpack:///./node_modules/lodash/_cacheHas.js","webpack:///./node_modules/babel-plugin-minify-simplify/lib/logical-expression.js","webpack:///./node_modules/babel-preset-minify/lib/index.js","webpack:///./node_modules/lodash/_SetCache.js","webpack:///./node_modules/babel-plugin-transform-property-literals/lib/property-name.js","webpack:///./node_modules/babel-plugin-transform-inline-consecutive-adds/lib/array-property-collapser.js","webpack:///./node_modules/lodash/_setCacheHas.js","webpack:///./node_modules/babel-plugin-transform-remove-undefined/lib/index.js","webpack:///./node_modules/babel-plugin-minify-replace/lib/index.js","webpack:///./node_modules/lodash/_hasPath.js","webpack:///./node_modules/lodash/_castPath.js","webpack:///./node_modules/lodash/memoize.js","webpack:///./node_modules/lodash/_basePropertyDeep.js","webpack:///./node_modules/babel-helper-mark-eval-scopes/lib/index.js","webpack:///./node_modules/lodash/_mapToArray.js","webpack:///./node_modules/lodash/_baseProperty.js","webpack:///./node_modules/babel-plugin-minify-mangle-names/lib/index.js","webpack:///./node_modules/babel-plugin-transform-remove-debugger/lib/index.js","webpack:///./node_modules/lodash/_toKey.js","webpack:///./node_modules/lodash/_isKey.js","webpack:///./node_modules/lodash/property.js","webpack:///./node_modules/babel-plugin-transform-property-literals/lib/index.js"],"names":["module","exports","removeUseStrict","newIssueUrl","useStrict","block","isBlockStatement","Error","type","useStricts","getUseStrictDirectives","length","i","remove","hasStrictParent","path","findParent","parent","isStrict","dir","get","Array","isArray","filter","directive","node","value","Collapser","ObjectCollapser","init","isObjectExpression","expr","isAssignmentExpression","objName","checkReference","left","isMemberExpression","obj","prop","isIdentifier","name","computed","isStringLiteral","isNumericLiteral","right","property","t","properties","push","objectProperty","evaluate","evaluateTruthy","res","confident","types","flipExpressions","visitor","LogicalExpression","enter","shouldBail","parentPath","isExpressionStatement","operator","leftTruthy","replaceWith","isPure","hasSeen","isSequenceExpression","shouldFlip","newNode","flip","this","map","Map","keys","has","set","count","delete","isObject","isStrictComparable","_require","FALLBACK_HANDLER","getName","member","swap","handlers","args","key","handler","hop","bind","replacement","apply","o","Object","prototype","hasOwnProperty","call","babel","replacements","seen","Symbol","isBinaryExpression","literal","bin","relevant","getLeaf","direction","stringLiteral","opts","tdz","isLiteral","isExportSpecifier","isUnaryExpression","argument","Number","isInteger","Infinity","unaryExpression","numericLiteral","valueToNode","helpers","object","calls","canReplace","arguments","members","stringValue","result","nSingle","nDouble","l","ch","delim","charAt","state","callee","isIncludedConsole","exclude","createVoid0","isIncludedConsoleBind","createNoop","MemberExpression","parentKey","isGlobalConsoleId","id","scope","getBinding","hasGlobal","isExcluded","excludeArray","some","memberExpr","functionExpression","blockStatement","_createForOfIteratorHelper","allowArrayLike","it","iterator","_unsupportedIterableToArray","F","s","n","done","e","_e","f","TypeError","err","normalCompletion","didErr","step","next","_e2","return","minLen","_arrayLikeToArray","toString","slice","constructor","from","test","arr","len","arr2","markEvalScopes","hasEval","prevSiblings","siblings","getSibling","forEachAncestor","callback","traverse","removeOrVoid","shouldRevisit","markForRemoval","main","Function","optimizeRawSize","Set","declars","mutations","bindings","binding","isVariableDeclarator","declarPath","add","isForInStatement","isFunction","declarations","assignmentSequence","_step","_iterator","declar","assignmentExpression","sequenceExpression","forEach","_step2","_iterator2","body","statement","isVariableDeclaration","varDecl","variableDeclaration","unshift","Scope","visit","isProgram","canRemoveParams","kind","paramsList","param","isAssignmentPattern","referenced","constant","isFunctionDeclaration","fun","allInside","_step3","_iterator3","referencePaths","ref","find","p","removeBinding","updateReferences","references","replacementPath","isReferencedBefore","refPath","_prevSiblings","ancestor","indexOf","bail","constantViolations","isThisExpression","skip","stop","mayLoop","sharesRoot","isWhileStatement","isFor","isObj","isArrayExpression","isRegExpLiteral","isReplacementObj","inExpression","replaced","replace","keepFnArgs","declaration","maybeBlockParent","isForXStatement","isFunctionExpression","isClassExpression","isClassDeclaration","isArrayPattern","isObjectPattern","paths","purge","isCompletionStatement","canExistAfterCompletion","inList","container","pushContext","context","popContext","noNext","hasLoopParent","nextPath","isReturnStatement","evaluateTest","consequent","alternate","SwitchStatement","discriminantPath","evaluated","beforeTest","expressions","lastExpression","expressionStatement","discriminant","cases","matchingCaseIndex","defaultCaseIndex","testResult","replaceWithMultiple","extractVars","getStatementsUntilBreak","start","statements","j","_isBreaking","isBreaking","break","replaceSwitch","isBlockRequired","BlockStatement","stmts","_step4","_iterator4","stmt","_isContinuing","isContinuing","continue","isBreakStatement","isContinueStatement","prev","keepFnName","removeUnreferencedId","keepClassName","getFunctionParent","variableDeclarator","IfStatement","evalResult","extractSequenceImpure","toStatements","Program","clearCache","cache","clear","crawl","functionToBindings","hasBlockScoped","bodyNode","isBlockScoped","declarators","_step5","_iterator5","decl","bindingIds","getBindingIdentifiers","identifier","varPath","isSameFunctionScope","_step6","_iterator6","options","isClass","fnName","isExpression","toExpression","fnToDeletePath","index","splice","isAncestor","path1","path2","isControlTransfer","control","_break$continue","checker","_isControlTransfer","isTransferred","cPath","label","labelPath","getLabel","_isAncestor","isCTransfer","possibleRunTimeControlTransfer","isLoop","isSwitchCase","isIfStatement","_path","seq","CountedSet","isLabelIdentifier","getProgramParent","oldName","newName","hasReference","hasBinding","tracker","hasBindingOrReference","maybeDecl","maybeFor","isForLoopBinding","isForStatement","fnParent","parentFunctionBinding","parentFunctionHasParamBinding","violation","canUse","existingBinding","toScope","isIterationStatement","isStatement","isSourceElement","trailingStatement","isProblematicIfStatement","current","isVoid0","EQUALITY_BINARY_OPERATORS","BOOLEAN_NUMBER_BINARY_OPERATORS","createRegExpLiteral","prettify","evaluatedArgs","a","every","pattern","flags","RegExp","source","regExpLiteral","maybeReplaceWithRegExpLiteral","baseIsEqual","hasIn","isKey","matchesStrictComparable","toKey","COMPARE_PARTIAL_FLAG","COMPARE_UNORDERED_FLAG","baseMatchesProperty","srcValue","objValue","undefined","memoizeCapped","rePropName","reEscapeChar","stringToPath","string","charCodeAt","match","number","quote","subString","CHARSET","split","shouldConsider","chars","frequency","c","finalized","str","sort","b","num","ret","Math","floor","customTypeAnnotation","typeAnnotation","violations","_iteratorNormalCompletion","_didIteratorError","_iteratorError","getTypeAnnotation","createUnionTypeAnnotation","baseTypeStrictlyMatches","leftTypes","rightTypes","isAnyTypeAnnotation","concat","isFlowBaseAnnotation","op","strictMatch","h","PatternMatch","not","notnot","or","logicalExpression","and","simplifyPatterns","_h$typeSymbols","typeSymbols","EX","Expression","matcher","isPatternMatchesPath","expression","emptyStatement","Uint8Array","eq","equalArrays","mapToArray","setToArray","boolTag","dateTag","errorTag","mapTag","numberTag","regexpTag","setTag","stringTag","symbolTag","arrayBufferTag","dataViewTag","symbolProto","symbolValueOf","valueOf","equalByTag","other","tag","bitmask","customizer","equalFunc","stack","byteLength","byteOffset","buffer","message","convert","isPartial","size","stacked","memoize","MAX_MEMOIZE_SIZE","func","baseFor","baseForOwn","iteratee","mangler","program","fnScope","getOuterBindingIdentifierPaths","generateUid","rename","scopeTracker","moveBinding","baseHasIn","ES6Regex","ES5Regex","NON_ASCII_WHITESPACES","IDENTIFIER_START","IDENTIFIER_PART","isDecimalDigit","isHexDigit","isOctalDigit","isWhiteSpace","isLineTerminator","fromCodePoint","cp","String","fromCharCode","cu1","cu2","NonAsciiIdentifierStart","NonAsciiIdentifierPart","isIdentifierStartES5","isIdentifierPartES5","isIdentifierStartES6","isIdentifierPartES6","REPLACED","mergeNestedIfs","clone","toGuardedExpression","toTernary","conditionalExpression","toConditional","returnStatement","VOID_0","toReturn","nextArg","nextExpr","removeUnnecessaryElse","insertAfter","el","runTransforms","transforms","_i","transform","switchConsequent","_ref","conditionalReturnToGuards","exprs","ifStatement","simplify","arraySome","baseIteratee","baseSome","isIterateeCall","collection","predicate","guard","liftDeclaration","firstNode","pushContainer","VariableDeclaration","sibling","_slicedToArray","_arrayWithHoles","_iterableToArrayLimit","_nonIterableRest","_arr","_n","_d","_s","COLLAPSERS","scopeParent","getFunctionReferences","getIdAndFunctionReferences","reduce","validateTopLevel","isBlockParent","isScopable","startIndex","collectExpressions","isExprTypeValid","getContiguousStatementsAndExpressions","end","checkExpr","allExprs","getReferenceChecker","r","isDescendant","tryUseCollapser","collapser","topLevel","_topLevel","isInitTypeValid","_getContiguousStateme","isExpressionTypeValid","getExpressionChecker","_getContiguousStateme2","assignments","extractAssignment","oldInit","newInit","cloneDeep","assignment","addSuccessfully","isSizeSmaller","_topLevel2","flipSeen","topNode","savings","isLogicalExpression","resultNotUsed","lastNodeDesc","_lastNodeDesc","baseEach","getMatchData","array","createBaseEach","_toArray","_iterableToArray","iter","LEAF_NODE","patterns","decisionTree","makeDecisionTree","input","isMatch","NO_MATCH","matchedKey","root","_iteratorNormalCompletion2","_didIteratorError2","_iteratorError2","make","pattern0","_pattern","rest","baseGetTag","getPrototype","isObjectLike","objectTag","funcProto","objectProto","funcToString","objectCtorString","isPlainObject","proto","Ctor","baseIsMatch","baseMatches","matchData","toMultipleSequenceExpressions","condExprSeen","seqExprSeen","Statement","UnaryExpression","isConditionalExpression","COMPARISON_BINARY_OPERATORS","isConditional","cond","undefinedToNull","exit","AssignmentExpression","ConditionalExpression","flipNegation","topPath","firstLeft","isNodesEquivalent","tests","alt","curTest","inits","empty","fitsInSlidingWindow","earlyReturnTransform","For","earlyContinueTransform","ForStatement","consumed","referencedOutsideLoop","ids","idloop","refs","breakAt","getSource","top","bottom","needsBlock","directives","isArrowFunctionExpression","ThrowStatement","createPrevExpressionEater","ReturnStatement","forStatement","ForInStatement","SequenceExpression","flatten","_iteratorNormalCompletion3","_didIteratorError3","_iteratorError3","consTestPairs","defaultRet","fallThru","_iteratorNormalCompletion4","_didIteratorError4","_iteratorError4","switchCase","cons","binaryExpression","reduceRight","isSwitchStatement","exprTestPairs","defaultExpr","_iteratorNormalCompletion5","_didIteratorError5","_iteratorError5","_switchCase$consequen","breakStatement","lastCase","potentialBreak","isTryStatement","isCatchClause","isSingleBlockScopeDeclaration","genericEarlyExitTransform","listKey","deopt","_i2","_i3","keyword","lastExpr","isPureVoid","isGlobalUndefined","nullLiteral","castPath","baseGet","VALID_CALLEES","INVALID_METHODS","addToMap","isComputed","BuiltInReplacer","pathsToUpdate","collectVisitor","isBuiltInComputed","isCallExpression","isBuiltin","expName","memberToString","CallExpression","_step$value","segmentsMap","getSegmentedSubPaths","_step2$value","subpaths","uniqueIdentifier","generateUidIdentifier","target","builtin","memberExpression","getGlobalThis","unshiftContainer","builtInReplacer","assign","getCollectVisitor","memberExprNode","segments","getDeepestCommonAncestorFrom","lastCommon","ancestries","fnPath","getChildFuncion","validDescendants","ancestors","callExpression","getFields","VISITOR_KEYS","_visitor","explode","queue","shift","fns","fn","fields","field","child","ast","code","operators","updateOperators","areArraysEqual","arr1","getPropNames","propNames","rightExpr","leftExpr","canBeUpdateExpression","leftPropNames","rightPropNames","newExpression","updateExpression","Stack","equalObjects","getTag","isBuffer","isTypedArray","argsTag","arrayTag","baseIsEqualDeep","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","HASH_UNDEFINED","setCacheAdd","__data__","testKey","TYPES","for","isNodeOfType","typeSymbol","keyFor","_isPatternMatchesPath","patternValue","inputPath","hasPath","newProp","parseInt","isValidIdentifier","ArrayCollapser","elements","isStrictModeReservedWordES6","isKeywordES5","strict","isKeywordES6","isReservedWordES5","isReservedWordES6","isRestrictedWord","isIdentifierNameES5","iz","decodeUtf16","lead","trail","isIdentifierNameES6","lowCh","check","isIdentifierES5","isIdentifierES6","isArrayLike","eachFunc","fromRight","iterable","noCustomizer","data","SetCollapser","isNewExpression","arg","arrayExpression","defaultValue","extra","normal","exponential","toExponential","lastChar","substr","lastIndexOf","dotIndex","subLength","raw","SetCache","cacheHas","arrLength","othLength","arrStacked","othStacked","arrValue","othValue","compared","othIndex","INFINITY","isObjectProperty","getBindingIdentifierPaths","isLabeledStatement","replaceArray","constructorArgs","fill","dropNewIfPresent","transformables","replaceObject","objectExpression","defaults","boolean","NotImplementedError","undef","isUndef","ob","defaultZero","cb","hasSpread","isSpreadElement","ArrayExpression","sep","bad","evaled","join","reverse","StringLiteral","realSep","codePointAt","retStatements","bailed","bailedAtIndex","nodes","comments","leadingComments","TRUE","FALSE","getAllKeys","objProps","objLength","othProps","objStacked","skipCtor","objCtor","othCtor","identity","baseEvaluate","error","evaluateIdentifier","isReferencedIdentifier","NaN","shouldDeoptBasedOnScope","flowEvalResult","evaluateBasedOnControlFlow","shouldDeopt","removed","blockParentPath","getBlockParent","blockParent","blockBody","compareResult","compareBindingAndReference","reference","idx","declarator","scopePath","scopeNode","entries","deoptPath","nodeParent","idPath","OP_AND","OP_OR","evaluateMemo","TRUTHY","FALSY","_e3","PLUGINS","PROXIES","preset","_opts","validOptions","pluginsMap","acc","plugin","enabled","proxyname","to","plugins","minified","presets","passPerPreset","MapCache","setCacheHas","values","escapeStringLiteral","reduceStaticPropertyNameES5","Identifier","parseFloat","NumericLiteral","ArrayPropertyCollapser","checkIndex","rval","anyUndefined","statementsLength","numCommaAdded","sizeOfRvals","isPureAndUndefined","evaluation","getLoopParent","hasViolation","v","violationStart","loop","NO_MEMBER","replaceVisitor","optionsMap","create","identifierName","globals","isArguments","isIndex","isLength","hasFunc","FUNC_ERROR_TEXT","resolver","memoized","Cache","basePropertyDeep","EVAL_SCOPE_MARKER","getEvalScopes","evalScopes","evalScope","evalPath","isMarked","baseProperty","Charset","ScopeTracker","bfsTraverseCreator","fixupVarScoping","isEvalScopesMarked","toObject","bfsTraverse","Mangler","charset","eval","_eval","visitedScopes","renamedNodes","crawlScope","collect","fixup","mangle","addScope","addBinding","addReference","registerBinding","consider","Literal","isExportNamedDeclaration","cannotMangle","isExportedWithName","canUseInReferencedScopes","names","counter","_names","canMangle","getIdentifier","isValidName","mangleScope","renameBindingIds","renameBinding","updateReference","actualBinding","shouldConsiderSource","run","isSymbol","reIsDeepProp","reIsPlainProp","ObjectProperty"],"mappings":"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","file":"js/chunk-085c2334.7f1f6ef8.js","sourcesContent":["\"use strict\";\n\nmodule.exports = removeUseStrict;\nconst newIssueUrl = \"https://github.com/babel/minify/issues/new\";\nconst useStrict = \"use strict\";\n/**\n * Remove redundant use strict\n * If the parent has a \"use strict\" directive, it is not required in\n * the children\n *\n * @param {NodePath} block BlockStatement\n */\n\nfunction removeUseStrict(block) {\n  if (!block.isBlockStatement()) {\n    throw new Error(`Received ${block.type}. Expected BlockStatement. ` + `Please report at ${newIssueUrl}`);\n  }\n\n  const useStricts = getUseStrictDirectives(block); // early exit\n\n  if (useStricts.length < 1) return; // only keep the first use strict\n\n  if (useStricts.length > 1) {\n    for (let i = 1; i < useStricts.length; i++) {\n      useStricts[i].remove();\n    }\n  } // check if parent has an use strict\n\n\n  if (hasStrictParent(block)) {\n    useStricts[0].remove();\n  }\n}\n\nfunction hasStrictParent(path) {\n  return path.findParent(parent => parent.isBlockStatement() && isStrict(parent));\n}\n\nfunction isStrict(block) {\n  return getUseStrictDirectives(block).length > 0;\n}\n\nfunction getUseStrictDirectives(block) {\n  var dir = block.get(\"directives\");\n  return Array.isArray(dir) ? dir.filter(function (directive) {\n    return directive.node.value.value === useStrict;\n  }) : [];\n}","\"use strict\";\n\nconst Collapser = require(\"./collapser\");\n\nclass ObjectCollapser extends Collapser {\n  isInitTypeValid(init) {\n    return init.isObjectExpression();\n  }\n\n  isExpressionTypeValid(expr) {\n    return expr.isAssignmentExpression();\n  }\n\n  getExpressionChecker(objName, checkReference) {\n    return expr => {\n      // checks expr is of form:\n      // foo.a = rval | foo[a] = rval\n      const left = expr.get(\"left\");\n\n      if (!left.isMemberExpression()) {\n        return false;\n      }\n\n      const obj = left.get(\"object\"),\n            prop = left.get(\"property\");\n\n      if (!obj.isIdentifier() || obj.node.name !== objName) {\n        return false;\n      }\n\n      if (!prop.isIdentifier() && checkReference(prop)) {\n        return false;\n      }\n\n      if (left.node.computed && !(prop.isStringLiteral() || prop.isNumericLiteral())) {\n        return false;\n      }\n\n      const right = expr.get(\"right\");\n\n      if (checkReference(right)) {\n        return false;\n      }\n\n      return true;\n    };\n  }\n\n  extractAssignment(expr) {\n    return [expr.node.left.property, expr.node.right];\n  }\n\n  addSuccessfully(t, [left, right], init) {\n    init.properties.push(t.objectProperty(left, right));\n    return true;\n  }\n\n}\n\nmodule.exports = ObjectCollapser;","\"use strict\";\n\nconst evaluate = require(\"babel-helper-evaluate-path\");\n\nfunction evaluateTruthy(path) {\n  const res = evaluate(path);\n  if (res.confident) return !!res.value;\n}\n\nmodule.exports = function ({\n  types: t\n}) {\n  const flipExpressions = require(\"babel-helper-flip-expressions\")(t);\n\n  return {\n    name: \"minify-guarded-expressions\",\n    visitor: {\n      // Convert guarded expressions\n      // !a && b() --> a || b();\n      // This could change the return result of the expression so we only do it\n      // on things where the result is ignored.\n      LogicalExpression: {\n        enter: [function (path) {\n          const node = path.node;\n          const left = path.get(\"left\");\n          const right = path.get(\"right\"); // issues - 171, 174, 176\n          // we assume that it is returned/assigned/part of a bigger expression\n          // or utilized somehow\n          // we check if we shouldBail only when evaluating\n          // the rightside of the expression;\n          // if the left side is evaluated to be deterministic,\n          // we can safely replace the entire expression\n\n          const shouldBail = !path.parentPath.isExpressionStatement();\n\n          if (node.operator === \"&&\") {\n            const leftTruthy = evaluateTruthy(left);\n\n            if (leftTruthy === false) {\n              // Short-circuit\n              path.replaceWith(node.left);\n            } else if (leftTruthy === true && left.isPure()) {\n              path.replaceWith(node.right);\n            } else if (evaluateTruthy(right) === false && right.isPure() && !shouldBail) {\n              path.replaceWith(node.left);\n            }\n          } else if (node.operator === \"||\") {\n            const leftTruthy = evaluateTruthy(left);\n\n            if (leftTruthy === false && left.isPure()) {\n              path.replaceWith(node.right);\n            } else if (leftTruthy === true) {\n              // Short-circuit\n              path.replaceWith(node.left);\n            } else if (evaluateTruthy(right) === false && right.isPure() && !shouldBail) {\n              path.replaceWith(node.left);\n            }\n          }\n        }, function (path) {\n          const node = path.node;\n\n          if (flipExpressions.hasSeen(node)) {\n            return;\n          }\n\n          if (!path.parentPath.isExpressionStatement() && !(path.parentPath.isSequenceExpression() && path.parentPath.parentPath.isExpressionStatement())) {\n            return;\n          } // Start counting savings from one since we can ignore the last\n          // expression.\n\n\n          if (flipExpressions.shouldFlip(node, 1)) {\n            const newNode = flipExpressions.flip(node, true);\n            path.replaceWith(newNode);\n          }\n        }]\n      }\n    }\n  };\n};","\"use strict\";\n\n// Set that counts\nmodule.exports = class CountedSet {\n  constructor() {\n    // because you can't simply extend Builtins yet\n    this.map = new Map();\n  }\n\n  keys() {\n    return [...this.map.keys()];\n  }\n\n  has(value) {\n    return this.map.has(value);\n  }\n\n  add(value) {\n    if (!this.has(value)) {\n      this.map.set(value, 0);\n    }\n\n    this.map.set(value, this.map.get(value) + 1);\n  }\n\n  delete(value) {\n    if (!this.has(value)) return;\n    const count = this.map.get(value);\n\n    if (count <= 1) {\n      this.map.delete(value);\n    } else {\n      this.map.set(value, count - 1);\n    }\n  }\n\n};","var isObject = require('./isObject');\n\n/**\n * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` if suitable for strict\n *  equality comparisons, else `false`.\n */\nfunction isStrictComparable(value) {\n  return value === value && !isObject(value);\n}\n\nmodule.exports = isStrictComparable;\n","\"use strict\";\n\nconst evaluate = require(\"babel-helper-evaluate-path\");\n\nconst _require = require(\"./replacements\"),\n      FALLBACK_HANDLER = _require.FALLBACK_HANDLER;\n\nfunction getName(member) {\n  if (member.computed) {\n    switch (member.property.type) {\n      case \"StringLiteral\":\n      case \"NumericLiteral\":\n        return member.property.value;\n\n      case \"TemplateLiteral\":\n        return;\n    }\n  } else {\n    return member.property.name;\n  }\n}\n\nfunction swap(path, member, handlers, ...args) {\n  const key = getName(member.node);\n  if (key === void 0) return false;\n  let handler;\n\n  if (hop(handlers, key) && typeof handlers[key] === \"function\") {\n    handler = handlers[key];\n  } else if (typeof handlers[FALLBACK_HANDLER] === \"function\") {\n    handler = handlers[FALLBACK_HANDLER].bind(member.get(\"object\"), key);\n  } else {\n    return false;\n  }\n\n  const replacement = handler.apply(member.get(\"object\"), args);\n\n  if (replacement) {\n    path.replaceWith(replacement);\n    return true;\n  }\n\n  return false;\n}\n\nmodule.exports = babel => {\n  const replacements = require(\"./replacements.js\")(babel);\n\n  const seen = Symbol(\"seen\");\n  const t = babel.types;\n  return {\n    name: \"minify-constant-folding\",\n    visitor: {\n      // Evaluate string expressions that are next to each other\n      // but are not actually a binary expression.\n      // \"a\" + b + \"c\" + \"d\" -> \"a\" + b + \"cd\"\n      BinaryExpression(path) {\n        if (!path.isBinaryExpression({\n          operator: \"+\"\n        })) {\n          return;\n        }\n\n        let literal, bin;\n        const left = path.get(\"left\");\n        const right = path.get(\"right\");\n\n        if (right.isStringLiteral()) {\n          literal = right;\n\n          if (left.isBinaryExpression({\n            operator: \"+\"\n          })) {\n            bin = left;\n          } else {\n            return;\n          }\n        } else if (left.isStringLiteral()) {\n          literal = left;\n\n          if (right.isBinaryExpression({\n            operator: \"+\"\n          })) {\n            bin = right;\n          } else {\n            return;\n          }\n        } else {\n          return;\n        }\n\n        const relevant = getLeaf(bin, literal.key);\n\n        if (!relevant) {\n          return;\n        }\n\n        const value = literal.key === \"right\" ? relevant.node.value + literal.node.value : literal.node.value + relevant.node.value;\n        relevant.replaceWith(t.stringLiteral(value));\n        path.replaceWith(bin.node);\n\n        function getLeaf(path, direction) {\n          if (path.isStringLiteral()) {\n            return path;\n          } else if (path.isBinaryExpression({\n            operator: \"+\"\n          })) {\n            return getLeaf(path.get(direction), direction);\n          }\n        }\n      },\n\n      // TODO: look into evaluating binding too (could result in more code, but gzip?)\n      Expression(path, {\n        opts: {\n          tdz = false\n        } = {}\n      }) {\n        const node = path.node,\n              parent = path.parent;\n\n        if (node[seen]) {\n          return;\n        }\n\n        if (path.isLiteral()) {\n          return;\n        }\n\n        if (!path.isPure()) {\n          return;\n        } // Avoid replacing the values for identifiers in exports\n\n\n        if (t.isExportSpecifier(parent)) {\n          return;\n        } // -0 maybe compared via dividing and then checking against -Infinity\n        // Also -X will always be -X.\n\n\n        if (t.isUnaryExpression(node, {\n          operator: \"-\"\n        }) && t.isNumericLiteral(node.argument)) {\n          return;\n        } // We have a transform that converts true/false to !0/!1\n\n\n        if (t.isUnaryExpression(node, {\n          operator: \"!\"\n        }) && t.isNumericLiteral(node.argument)) {\n          if (node.argument.value === 0 || node.argument.value === 1) {\n            return;\n          }\n        } // void 0 is used for undefined.\n\n\n        if (t.isUnaryExpression(node, {\n          operator: \"void\"\n        }) && t.isNumericLiteral(node.argument, {\n          value: 0\n        })) {\n          return;\n        }\n\n        const res = evaluate(path, {\n          tdz\n        });\n\n        if (res.confident) {\n          // Avoid fractions because they can be longer than the original expression.\n          // There is also issues with number precision?\n          if (typeof res.value === \"number\" && !Number.isInteger(res.value)) {\n            return;\n          } // Preserve -0\n\n\n          if (typeof res.value === \"number\" && res.value === 0) {\n            if (1 / res.value === -Infinity) {\n              const node = t.unaryExpression(\"-\", t.numericLiteral(0), true);\n              node[seen] = true;\n              path.replaceWith(node);\n              return;\n            }\n          } // this will convert object to object but\n          // t.valueToNode has other effects where property name\n          // is not treated for the respective environment.\n          // So we bail here for objects and let other plugins\n          // take care of converting String literal to Identifier\n\n\n          if (typeof res.value === \"object\") {\n            return;\n          }\n\n          const node = t.valueToNode(res.value);\n          node[seen] = true;\n          path.replaceWith(node);\n        }\n      },\n\n      CallExpression(path) {\n        const node = path.node;\n        const member = path.get(\"callee\");\n\n        if (t.isMemberExpression(member)) {\n          const helpers = replacements[member.node.object.type];\n          if (!helpers || !helpers.calls) return; // find if the input can be constant folded\n\n          if (typeof helpers.canReplace === \"function\" && !helpers.canReplace.call(member.get(\"object\"))) {\n            return;\n          }\n\n          swap(path, member, helpers.calls, ...node.arguments);\n        }\n      },\n\n      MemberExpression(path) {\n        const node = path.node;\n        const helpers = replacements[node.object.type];\n        if (!helpers || !helpers.members) return;\n        swap(path, path, helpers.members);\n      }\n\n    }\n  };\n};\n\nfunction hop(o, key) {\n  return Object.prototype.hasOwnProperty.call(o, key);\n}","\"use strict\";\n/**\n * Original Source:\n * https://github.com/shapesecurity/shift-codegen-js/blob/0d09bd8a/src/coderep.js#L122\n *\n * The following function is an exact copy of the original implementation\n *\n * LICENSE\n\nCopyright 2014 Shape Security, Inc.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\n */\n\nmodule.exports = function escapeStringLiteral(stringValue) {\n  let result = \"\";\n  let nSingle = 0,\n      nDouble = 0;\n\n  for (let i = 0, l = stringValue.length; i < l; ++i) {\n    let ch = stringValue[i];\n\n    if (ch === '\"') {\n      ++nDouble;\n    } else if (ch === \"'\") {\n      ++nSingle;\n    }\n  }\n\n  let delim = nDouble > nSingle ? \"'\" : '\"';\n  result += delim;\n\n  for (let i = 0; i < stringValue.length; i++) {\n    let ch = stringValue.charAt(i);\n\n    switch (ch) {\n      case delim:\n        result += \"\\\\\" + delim;\n        break;\n\n      case \"\\n\":\n        result += \"\\\\n\";\n        break;\n\n      case \"\\r\":\n        result += \"\\\\r\";\n        break;\n\n      case \"\\\\\":\n        result += \"\\\\\\\\\";\n        break;\n\n      case \"\\u2028\":\n        result += \"\\\\u2028\";\n        break;\n\n      case \"\\u2029\":\n        result += \"\\\\u2029\";\n        break;\n\n      default:\n        result += ch;\n        break;\n    }\n  }\n\n  result += delim;\n  return result;\n};","\"use strict\";\n\nmodule.exports = function ({\n  types: t\n}) {\n  return {\n    name: \"transform-remove-console\",\n    visitor: {\n      CallExpression(path, state) {\n        const callee = path.get(\"callee\");\n        if (!callee.isMemberExpression()) return;\n\n        if (isIncludedConsole(callee, state.opts.exclude)) {\n          // console.log()\n          if (path.parentPath.isExpressionStatement()) {\n            path.remove();\n          } else {\n            path.replaceWith(createVoid0());\n          }\n        } else if (isIncludedConsoleBind(callee, state.opts.exclude)) {\n          // console.log.bind()\n          path.replaceWith(createNoop());\n        }\n      },\n\n      MemberExpression: {\n        exit(path, state) {\n          if (isIncludedConsole(path, state.opts.exclude) && !path.parentPath.isMemberExpression()) {\n            if (path.parentPath.isAssignmentExpression() && path.parentKey === \"left\") {\n              path.parentPath.get(\"right\").replaceWith(createNoop());\n            } else {\n              path.replaceWith(createNoop());\n            }\n          }\n        }\n\n      }\n    }\n  };\n\n  function isGlobalConsoleId(id) {\n    const name = \"console\";\n    return id.isIdentifier({\n      name\n    }) && !id.scope.getBinding(name) && id.scope.hasGlobal(name);\n  }\n\n  function isExcluded(property, excludeArray) {\n    return excludeArray && excludeArray.some(name => property.isIdentifier({\n      name\n    }));\n  }\n\n  function isIncludedConsole(memberExpr, excludeArray) {\n    const object = memberExpr.get(\"object\");\n    const property = memberExpr.get(\"property\");\n    if (isExcluded(property, excludeArray)) return false;\n    if (isGlobalConsoleId(object)) return true;\n    return isGlobalConsoleId(object.get(\"object\")) && (property.isIdentifier({\n      name: \"call\"\n    }) || property.isIdentifier({\n      name: \"apply\"\n    }));\n  }\n\n  function isIncludedConsoleBind(memberExpr, excludeArray) {\n    const object = memberExpr.get(\"object\");\n    if (!object.isMemberExpression()) return false;\n    if (isExcluded(object.get(\"property\"), excludeArray)) return false;\n    return isGlobalConsoleId(object.get(\"object\")) && memberExpr.get(\"property\").isIdentifier({\n      name: \"bind\"\n    });\n  }\n\n  function createNoop() {\n    return t.functionExpression(null, [], t.blockStatement([]));\n  }\n\n  function createVoid0() {\n    return t.unaryExpression(\"void\", t.numericLiteral(0));\n  }\n};","\"use strict\";\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\n\nconst some = require(\"lodash/some\");\n\nconst _require = require(\"babel-helper-mark-eval-scopes\"),\n      markEvalScopes = _require.markEvalScopes,\n      hasEval = _require.hasEval;\n\nconst removeUseStrict = require(\"./remove-use-strict\");\n\nconst evaluate = require(\"babel-helper-evaluate-path\");\n\nfunction evaluateTruthy(path) {\n  const res = evaluate(path);\n  if (res.confident) return !!res.value;\n}\n\nfunction prevSiblings(path) {\n  const parentPath = path.parentPath;\n  const siblings = [];\n  let key = parentPath.key;\n\n  while ((path = parentPath.getSibling(--key)).type) {\n    siblings.push(path);\n  }\n\n  return siblings;\n}\n\nfunction forEachAncestor(path, callback) {\n  while (path = path.parentPath) {\n    callback(path);\n  }\n}\n\nmodule.exports = ({\n  types: t,\n  traverse\n}) => {\n  const removeOrVoid = require(\"babel-helper-remove-or-void\")(t);\n\n  const shouldRevisit = Symbol(\"shouldRevisit\"); // this is used for tracking fn params that can be removed\n  // as traversal takes place from left and\n  // unused params can be removed only on the right\n\n  const markForRemoval = Symbol(\"markForRemoval\");\n  const main = {\n    // remove side effectless statement\n    ExpressionStatement(path) {\n      if (path.get(\"expression\").isPure()) {\n        removeOrVoid(path);\n      }\n    },\n\n    Function: {\n      // Let's take all the vars in a function that are not in the top level scope and hoist them\n      // with the first var declaration in the top-level scope. This transform in itself may\n      // not yield much returns (or even can be marginally harmful to size). However it's great\n      // for taking away statements from blocks that can be only expressions which the `simplify`\n      // plugin can turn into other things (e.g. if => conditional).\n      exit(path) {\n        // This hurts gzip size.\n        if (!this.optimizeRawSize) {\n          return;\n        }\n\n        const node = path.node,\n              scope = path.scope;\n        const seen = new Set();\n        const declars = [];\n        const mutations = [];\n\n        for (const name in scope.bindings) {\n          const binding = scope.bindings[name];\n\n          if (!binding.path.isVariableDeclarator()) {\n            continue;\n          }\n\n          const declarPath = binding.path.parentPath;\n\n          if (seen.has(declarPath)) {\n            continue;\n          }\n\n          seen.add(declarPath);\n\n          if (declarPath.parentPath.isForInStatement()) {\n            continue;\n          }\n\n          if (declarPath.parentPath.parentPath.isFunction()) {\n            continue;\n          }\n\n          if (!declarPath.node || !declarPath.node.declarations) {\n            continue;\n          }\n\n          const assignmentSequence = [];\n\n          var _iterator = _createForOfIteratorHelper(declarPath.node.declarations),\n              _step;\n\n          try {\n            for (_iterator.s(); !(_step = _iterator.n()).done;) {\n              const declar = _step.value;\n              declars.push(declar);\n\n              if (declar.init) {\n                assignmentSequence.push(t.assignmentExpression(\"=\", declar.id, declar.init));\n                mutations.push(() => {\n                  declar.init = null;\n                });\n              }\n            }\n          } catch (err) {\n            _iterator.e(err);\n          } finally {\n            _iterator.f();\n          }\n\n          if (assignmentSequence.length) {\n            mutations.push(() => declarPath.replaceWith(t.sequenceExpression(assignmentSequence)));\n          } else {\n            mutations.push(() => removeOrVoid(declarPath));\n          }\n        }\n\n        if (declars.length) {\n          mutations.forEach(f => f());\n\n          var _iterator2 = _createForOfIteratorHelper(node.body.body),\n              _step2;\n\n          try {\n            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n              const statement = _step2.value;\n\n              if (t.isVariableDeclaration(statement)) {\n                statement.declarations.push(...declars);\n                return;\n              }\n            }\n          } catch (err) {\n            _iterator2.e(err);\n          } finally {\n            _iterator2.f();\n          }\n\n          const varDecl = t.variableDeclaration(\"var\", declars);\n          node.body.body.unshift(varDecl);\n        }\n      }\n\n    },\n    // Remove bindings with no references.\n    Scope: {\n      exit(path) {\n        if (path.node[shouldRevisit]) {\n          delete path.node[shouldRevisit];\n          path.visit();\n        }\n      },\n\n      enter(path) {\n        if (path.isProgram()) {\n          return;\n        }\n\n        if (hasEval(path.scope)) {\n          return;\n        }\n\n        const scope = path.scope; // if the scope is created by a function, we obtain its\n        // parameter list\n\n        const canRemoveParams = path.isFunction() && path.node.kind !== \"set\";\n        const paramsList = canRemoveParams ? path.get(\"params\") : [];\n\n        for (let i = paramsList.length - 1; i >= 0; i--) {\n          const param = paramsList[i];\n\n          if (param.isIdentifier()) {\n            const binding = scope.bindings[param.node.name];\n            if (!binding) continue;\n\n            if (binding.referenced) {\n              // when the first binding is referenced (right to left)\n              // exit without marking anything after this\n              break;\n            }\n\n            binding[markForRemoval] = true;\n            continue;\n          } else if (param.isAssignmentPattern()) {\n            const left = param.get(\"left\");\n            const right = param.get(\"right\");\n\n            if (left.isIdentifier() && right.isPure()) {\n              const binding = scope.bindings[left.node.name];\n\n              if (binding.referenced) {\n                // when the first binding is referenced (right to left)\n                // exit without marking anything after this\n                break;\n              }\n\n              binding[markForRemoval] = true;\n              continue;\n            }\n          } // other patterns - assignment, object have side-effects\n          // and cannot be safely removed\n\n\n          break;\n        }\n\n        for (const name in scope.bindings) {\n          const binding = scope.bindings[name];\n\n          if (!binding.referenced && binding.kind !== \"module\") {\n            if (binding.kind === \"param\" && (this.keepFnArgs || !binding[markForRemoval])) {\n              continue;\n            } else if (binding.path.isVariableDeclarator()) {\n              const declaration = binding.path.parentPath;\n              const maybeBlockParent = declaration.parentPath;\n\n              if (maybeBlockParent && maybeBlockParent.isForXStatement({\n                left: declaration.node\n              })) {\n                // Can't remove if in a for-in/for-of/for-await statement `for (var x in wat)`.\n                continue;\n              }\n            } else if (!scope.isPure(binding.path.node)) {\n              // TODO: AssignmentPattern are marked as impure and unused ids aren't removed yet\n              continue;\n            } else if (binding.path.isFunctionExpression() || binding.path.isClassExpression()) {\n              // `bar(function foo() {})` foo is not referenced but it's used.\n              continue;\n            } else if ( // ClassDeclaration has binding in two scopes\n            //   1. The scope in which it is declared\n            //   2. The class's own scope\n            binding.path.isClassDeclaration() && binding.path === scope.path) {\n              continue;\n            }\n\n            const mutations = [];\n            let bail = false; // Make sure none of the assignments value is used\n\n            binding.constantViolations.forEach(p => {\n              if (bail || p === binding.path) {\n                return;\n              }\n\n              if (!p.parentPath.isExpressionStatement()) {\n                bail = true;\n              }\n\n              if (p.isAssignmentExpression()) {\n                if (t.isArrayPattern(p.node.left) || t.isObjectPattern(p.node.left)) {\n                  bail = true;\n                } else if (p.get(\"right\").isPure()) {\n                  mutations.push(() => removeOrVoid(p));\n                } else {\n                  mutations.push(() => p.replaceWith(p.get(\"right\")));\n                }\n              }\n            });\n\n            if (bail) {\n              continue;\n            }\n\n            if (binding.path.isVariableDeclarator()) {\n              if (!binding.path.get(\"id\").isIdentifier()) {\n                // deopt for object and array pattern\n                continue;\n              } // if declarator has some impure init expression\n              // var x = foo();\n              // => foo();\n\n\n              if (binding.path.node.init && !scope.isPure(binding.path.node.init) && binding.path.parentPath.node.declarations) {\n                // binding path has more than one declarations\n                if (binding.path.parentPath.node.declarations.length !== 1) {\n                  continue;\n                }\n\n                binding.path.parentPath.replaceWith(binding.path.node.init);\n              } else {\n                updateReferences(binding.path, this);\n                removeOrVoid(binding.path);\n              }\n            } else {\n              updateReferences(binding.path, this);\n              removeOrVoid(binding.path);\n            }\n\n            mutations.forEach(f => f());\n            scope.removeBinding(name);\n          } else if (binding.constant) {\n            if (binding.path.isFunctionDeclaration() || binding.path.isVariableDeclarator() && binding.path.get(\"init\").isFunction()) {\n              const fun = binding.path.isFunctionDeclaration() ? binding.path : binding.path.get(\"init\");\n              let allInside = true;\n\n              var _iterator3 = _createForOfIteratorHelper(binding.referencePaths),\n                  _step3;\n\n              try {\n                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n                  const ref = _step3.value;\n\n                  if (!ref.find(p => p.node === fun.node)) {\n                    allInside = false;\n                    break;\n                  }\n                }\n              } catch (err) {\n                _iterator3.e(err);\n              } finally {\n                _iterator3.f();\n              }\n\n              if (allInside) {\n                scope.removeBinding(name);\n                updateReferences(binding.path, this);\n                removeOrVoid(binding.path);\n                continue;\n              }\n            }\n\n            if (binding.references === 1 && binding.kind !== \"param\" && binding.kind !== \"module\" && binding.constant) {\n              let replacement = binding.path.node;\n              let replacementPath = binding.path;\n              let isReferencedBefore = false;\n              const refPath = binding.referencePaths[0];\n\n              if (t.isVariableDeclarator(replacement)) {\n                const _prevSiblings = prevSiblings(replacementPath); // traverse ancestors of a reference checking if it's before declaration\n\n\n                forEachAncestor(refPath, ancestor => {\n                  if (_prevSiblings.indexOf(ancestor) > -1) {\n                    isReferencedBefore = true;\n                  }\n                }); // deopt if reference is in different scope than binding\n                // since we don't know if it's sync or async execution\n                // (i.e. whether value has been assigned to a reference or not)\n\n                if (isReferencedBefore && refPath.scope !== binding.scope) {\n                  continue;\n                } // simulate hoisting by replacing value\n                // with undefined if declaration is after reference\n\n\n                replacement = isReferencedBefore ? t.unaryExpression(\"void\", t.numericLiteral(0), true) : replacement.init; // Bail out for ArrayPattern and ObjectPattern\n                // TODO: maybe a more intelligent approach instead of simply bailing out\n\n                if (!replacementPath.get(\"id\").isIdentifier()) {\n                  continue;\n                }\n\n                replacementPath = replacementPath.get(\"init\");\n              }\n\n              if (!replacement) {\n                continue;\n              }\n\n              if (!scope.isPure(replacement, true) && !isReferencedBefore) {\n                continue;\n              }\n\n              let bail = false;\n\n              if (replacementPath.isIdentifier()) {\n                const binding = scope.getBinding(replacement.name); // the reference should be in the same scope\n                // and the replacement should be a constant - this is to\n                // ensure that the duplication of replacement is not affected\n                // https://github.com/babel/minify/issues/685\n\n                bail = !(binding && refPath.scope.getBinding(replacement.name) === binding && binding.constantViolations.length === 0);\n              } else if (replacementPath.isThisExpression()) {\n                bail = true;\n              } else {\n                replacementPath.traverse({\n                  Function(path) {\n                    path.skip();\n                  },\n\n                  ThisExpression(path) {\n                    bail = true;\n                    path.stop();\n                  },\n\n                  ReferencedIdentifier({\n                    node\n                  }) {\n                    const binding = scope.getBinding(node.name);\n\n                    if (binding && refPath.scope.getBinding(node.name) === binding) {\n                      bail = binding.constantViolations.length > 0;\n\n                      if (bail) {\n                        path.stop();\n                      }\n                    }\n                  }\n\n                });\n              }\n\n              if (bail) {\n                continue;\n              }\n\n              let parent = binding.path.parent;\n\n              if (t.isVariableDeclaration(parent)) {\n                parent = binding.path.parentPath.parent;\n              } // 1. Make sure we share the parent with the node. In other words it's lexically defined\n              // and not in an if statement or otherwise.\n              // 2. If the replacement is an object then we have to make sure we are not in a loop or a function\n              // because otherwise we'll be inlining and doing a lot more allocation than we have to\n              // which would also could affect correctness in that they are not the same reference.\n\n\n              let mayLoop = false;\n              const sharesRoot = refPath.find(({\n                node\n              }) => {\n                if (!mayLoop) {\n                  mayLoop = t.isWhileStatement(node) || t.isFor(node) || t.isFunction(node);\n                }\n\n                return node === parent;\n              }); // Anything that inherits from Object.\n\n              const isObj = n => t.isFunction(n) || t.isObjectExpression(n) || t.isArrayExpression(n) || t.isRegExpLiteral(n);\n\n              const isReplacementObj = isObj(replacement) || some(replacement, isObj);\n\n              if (!sharesRoot || isReplacementObj && mayLoop) {\n                continue;\n              } // check if it's safe to replace\n              // To solve https://github.com/babel/minify/issues/691\n              // Here we bail for property checks using the \"in\" operator\n              // This is because - `in` is a side-effect-free operation but the property\n              // could be deleted between the replacementPath and referencePath\n              // It is expensive to compute the delete operation and we bail for\n              // all the binary \"in\" operations\n\n\n              let inExpression = replacementPath.isBinaryExpression({\n                operator: \"in\"\n              });\n\n              if (!inExpression) {\n                replacementPath.traverse({\n                  Function(path) {\n                    path.skip();\n                  },\n\n                  BinaryExpression(path) {\n                    if (path.node.operator === \"in\") {\n                      inExpression = true;\n                      path.stop();\n                    }\n                  }\n\n                });\n              }\n\n              if (inExpression) {\n                continue;\n              }\n\n              const replaced = replace(binding.referencePaths[0], {\n                binding,\n                scope,\n                replacement,\n                replacementPath\n              });\n\n              if (replaced) {\n                scope.removeBinding(name);\n\n                if (binding.path.node) {\n                  removeOrVoid(binding.path);\n                }\n              }\n            }\n          }\n        } // end-for-of\n\n      }\n\n    },\n\n    // Remove unreachable code.\n    BlockStatement(path) {\n      const paths = path.get(\"body\");\n      let purge = false;\n\n      for (let i = 0; i < paths.length; i++) {\n        const p = paths[i];\n\n        if (!purge && p.isCompletionStatement()) {\n          purge = true;\n          continue;\n        }\n\n        if (purge && !canExistAfterCompletion(p)) {\n          removeOrVoid(p);\n        }\n      }\n    },\n\n    // Double check unreachable code and remove return statements that\n    // have no semantic meaning\n    ReturnStatement(path) {\n      const node = path.node;\n\n      if (!path.inList) {\n        return;\n      } // Not last in its block? (See BlockStatement visitor)\n\n\n      if (path.container.length - 1 !== path.key && !canExistAfterCompletion(path.getSibling(path.key + 1)) && path.parentPath.isBlockStatement()) {\n        // This is probably a new oppurtinity by some other transform\n        // let's call the block visitor on this again before proceeding.\n        path.parentPath.pushContext(path.context);\n        path.parentPath.visit();\n        path.parentPath.popContext();\n        return;\n      }\n\n      if (node.argument) {\n        return;\n      }\n\n      let noNext = true;\n      let parentPath = path.parentPath;\n\n      while (parentPath && !parentPath.isFunction() && noNext) {\n        // https://github.com/babel/minify/issues/265\n        if (hasLoopParent(parentPath)) {\n          noNext = false;\n          break;\n        }\n\n        const nextPath = parentPath.getSibling(parentPath.key + 1);\n\n        if (nextPath.node) {\n          if (nextPath.isReturnStatement()) {\n            nextPath.pushContext(path.context);\n            nextPath.visit();\n            nextPath.popContext();\n\n            if (parentPath.getSibling(parentPath.key + 1).node) {\n              noNext = false;\n              break;\n            }\n          } else {\n            noNext = false;\n            break;\n          }\n        }\n\n        parentPath = parentPath.parentPath;\n      }\n\n      if (noNext) {\n        removeOrVoid(path);\n      }\n    },\n\n    ConditionalExpression(path) {\n      const node = path.node;\n      const evaluateTest = evaluateTruthy(path.get(\"test\"));\n\n      if (evaluateTest === true) {\n        path.replaceWith(node.consequent);\n      } else if (evaluateTest === false) {\n        path.replaceWith(node.alternate);\n      }\n    },\n\n    SwitchStatement: {\n      exit(path) {\n        const discriminantPath = path.get(\"discriminant\");\n        const evaluated = evaluate(discriminantPath, {\n          tdz: this.tdz\n        });\n        if (!evaluated.confident) return; // the simplify transformation might have brought in the previous\n        // expressions into the switch's test expression and instead of\n        // bailing out of impure path, we collect the impurities of it's\n        // a sequence expression and bail out if the primary test itself\n        // is impure\n\n        let beforeTest = [];\n\n        if (t.isSequenceExpression(discriminantPath.node)) {\n          const expressions = discriminantPath.get(\"expressions\");\n          const lastExpression = expressions[expressions.length - 1];\n\n          if (!lastExpression.isPure()) {\n            return;\n          }\n\n          beforeTest = [t.expressionStatement(t.sequenceExpression(expressions.slice(0, expressions.length - 1).map(path => path.node)))];\n        } else if (!discriminantPath.isPure()) {\n          return;\n        }\n\n        const discriminant = evaluated.value;\n        const cases = path.get(\"cases\");\n        let matchingCaseIndex = -1;\n        let defaultCaseIndex = -1;\n\n        for (let i = 0; i < cases.length; i++) {\n          const test = cases[i].get(\"test\"); // handle default case\n\n          if (test.node === null) {\n            defaultCaseIndex = i;\n            continue;\n          }\n\n          const testResult = evaluate(test, {\n            tdz: this.tdz\n          }); // if we are not able to deternine a test during\n          // compile time, we terminate immediately\n\n          if (!testResult.confident) return;\n\n          if (testResult.value === discriminant) {\n            matchingCaseIndex = i;\n            break;\n          }\n        }\n\n        let result;\n\n        if (matchingCaseIndex === -1) {\n          if (defaultCaseIndex === -1) {\n            path.skip();\n            path.replaceWithMultiple(extractVars(path));\n            return;\n          } else {\n            result = getStatementsUntilBreak(defaultCaseIndex);\n          }\n        } else {\n          result = getStatementsUntilBreak(matchingCaseIndex);\n        }\n\n        if (result.bail) return; // we extract vars from the entire switch statement\n        // and there will be duplicates which\n        // will be again removed by DCE\n\n        replaceSwitch([...extractVars(path), ...beforeTest, ...result.statements]);\n\n        function getStatementsUntilBreak(start) {\n          const result = {\n            bail: false,\n            statements: []\n          };\n\n          for (let i = start; i < cases.length; i++) {\n            const consequent = cases[i].get(\"consequent\");\n\n            for (let j = 0; j < consequent.length; j++) {\n              const _isBreaking = isBreaking(consequent[j], path);\n\n              if (_isBreaking.bail) {\n                result.bail = true;\n                return result;\n              }\n\n              if (_isBreaking.break) {\n                // compute no more\n                // exit out of the loop\n                return result;\n              } else {\n                result.statements.push(consequent[j].node);\n              }\n            }\n          }\n\n          return result;\n        }\n\n        function replaceSwitch(statements) {\n          let isBlockRequired = false;\n\n          for (let i = 0; i < statements.length; i++) {\n            if (t.isVariableDeclaration(statements[i], {\n              kind: \"let\"\n            })) {\n              isBlockRequired = true;\n              break;\n            }\n\n            if (t.isVariableDeclaration(statements[i], {\n              kind: \"const\"\n            })) {\n              isBlockRequired = true;\n              break;\n            }\n          }\n\n          if (isBlockRequired) {\n            path.replaceWith(t.BlockStatement(statements));\n          } else {\n            path.replaceWithMultiple(statements);\n          }\n        }\n      }\n\n    },\n\n    WhileStatement(path) {\n      const test = path.get(\"test\");\n      const result = evaluate(test, {\n        tdz: this.tdz\n      });\n\n      if (result.confident && test.isPure() && !result.value) {\n        path.replaceWithMultiple(extractVars(path.get(\"body\")));\n      }\n    },\n\n    ForStatement(path) {\n      const test = path.get(\"test\");\n      if (!test.isPure()) return;\n      const result = evaluate(test, {\n        tdz: this.tdz\n      });\n\n      if (result.confident) {\n        if (result.value) {\n          test.remove();\n        } else {\n          const init = path.get(\"init\");\n\n          if (init.node && !init.isPure()) {\n            path.replaceWith(init);\n          } else {\n            path.remove();\n          }\n        }\n      }\n    },\n\n    DoWhileStatement(path) {\n      const test = path.get(\"test\");\n      const result = evaluate(test, {\n        tdz: this.tdz\n      });\n\n      if (result.confident && test.isPure() && !result.value) {\n        const body = path.get(\"body\");\n\n        if (body.isBlockStatement()) {\n          const stmts = body.get(\"body\");\n\n          var _iterator4 = _createForOfIteratorHelper(stmts),\n              _step4;\n\n          try {\n            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {\n              const stmt = _step4.value;\n\n              const _isBreaking = isBreaking(stmt, path);\n\n              if (_isBreaking.bail || _isBreaking.break) return;\n\n              const _isContinuing = isContinuing(stmt, path);\n\n              if (_isContinuing.bail || isContinuing.continue) return;\n            }\n          } catch (err) {\n            _iterator4.e(err);\n          } finally {\n            _iterator4.f();\n          }\n\n          path.replaceWith(body.node);\n        } else if (body.isBreakStatement()) {\n          const _isBreaking = isBreaking(body, path);\n\n          if (_isBreaking.bail) return;\n          if (_isBreaking.break) path.remove();\n        } else if (body.isContinueStatement()) {\n          return;\n        } else {\n          path.replaceWith(body.node);\n        }\n      }\n    },\n\n    // Join assignment and definition when in sequence.\n    // var x; x = 1; -> var x = 1;\n    AssignmentExpression(path) {\n      if (!path.get(\"left\").isIdentifier() || !path.parentPath.isExpressionStatement()) {\n        return;\n      }\n\n      const prev = path.parentPath.getSibling(path.parentPath.key - 1);\n\n      if (!(prev && prev.isVariableDeclaration())) {\n        return;\n      }\n\n      const declars = prev.node.declarations;\n\n      if (declars.length !== 1 || declars[0].init || declars[0].id.name !== path.get(\"left\").node.name) {\n        return;\n      }\n\n      declars[0].init = path.node.right;\n      removeOrVoid(path);\n    },\n\n    // Remove named function expression name. While this is dangerous as it changes\n    // `function.name` all minifiers do it and hence became a standard.\n    FunctionExpression(path) {\n      if (!this.keepFnName) {\n        removeUnreferencedId(path);\n      }\n    },\n\n    // remove class names\n    ClassExpression(path) {\n      if (!this.keepClassName) {\n        removeUnreferencedId(path);\n      }\n    },\n\n    // Put the `var` in the left if feasible.\n    ForInStatement(path) {\n      const left = path.get(\"left\");\n\n      if (!left.isIdentifier()) {\n        return;\n      }\n\n      const binding = path.scope.getBinding(left.node.name);\n\n      if (!binding) {\n        return;\n      }\n\n      if (binding.scope.getFunctionParent() !== path.scope.getFunctionParent()) {\n        return;\n      }\n\n      if (!binding.path.isVariableDeclarator()) {\n        return;\n      }\n\n      if (binding.path.parentPath.parentPath.isForInStatement({\n        left: binding.path.parent\n      })) {\n        return;\n      } // If it has company then it's probably more efficient to keep.\n\n\n      if (binding.path.parent.declarations.length > 1) {\n        return;\n      } // meh\n\n\n      if (binding.path.node.init) {\n        return;\n      }\n\n      removeOrVoid(binding.path);\n      path.node.left = t.variableDeclaration(\"var\", [t.variableDeclarator(left.node)]);\n      binding.path = path.get(\"left\").get(\"declarations\")[0];\n    }\n\n  };\n  return {\n    name: \"minify-dead-code-elimination\",\n    visitor: {\n      Function: {\n        exit(path) {\n          /**\n           * Use exit handler to traverse in a dfs post-order fashion\n           * to remove use strict\n           */\n          const body = path.get(\"body\");\n\n          if (body.isBlockStatement()) {\n            removeUseStrict(body);\n          }\n        }\n\n      },\n      IfStatement: {\n        exit(path, {\n          opts: {\n            tdz = false\n          } = {}\n        }) {\n          const consequent = path.get(\"consequent\");\n          const alternate = path.get(\"alternate\");\n          const test = path.get(\"test\");\n          const evalResult = evaluate(test, {\n            tdz\n          });\n          const isPure = test.isPure();\n          const replacements = [];\n\n          if (evalResult.confident && !isPure && test.isSequenceExpression()) {\n            replacements.push(t.expressionStatement(extractSequenceImpure(test)));\n          } // we can check if a test will be truthy 100% and if so then we can inline\n          // the consequent and completely ignore the alternate\n          //\n          //   if (true) { foo; } -> { foo; }\n          //   if (\"foo\") { foo; } -> { foo; }\n          //\n\n\n          if (evalResult.confident && evalResult.value) {\n            path.replaceWithMultiple([...replacements, ...toStatements(consequent), ...extractVars(alternate)]);\n            return;\n          } // we can check if a test will be falsy 100% and if so we can inline the\n          // alternate if there is one and completely remove the consequent\n          //\n          //   if (\"\") { bar; } else { foo; } -> { foo; }\n          //   if (\"\") { bar; } ->\n          //\n\n\n          if (evalResult.confident && !evalResult.value) {\n            if (alternate.node) {\n              path.replaceWithMultiple([...replacements, ...toStatements(alternate), ...extractVars(consequent)]);\n              return;\n            } else {\n              path.replaceWithMultiple([...replacements, ...extractVars(consequent)]);\n            }\n          } // remove alternate blocks that are empty\n          //\n          //   if (foo) { foo; } else {} -> if (foo) { foo; }\n          //\n\n\n          if (alternate.isBlockStatement() && !alternate.node.body.length) {\n            alternate.remove(); // For if-statements babel-traverse replaces with an empty block\n\n            path.node.alternate = null;\n          } // if the consequent block is empty turn alternate blocks into a consequent\n          // and flip the test\n          //\n          //   if (foo) {} else { bar; } -> if (!foo) { bar; }\n          //\n\n\n          if (consequent.isBlockStatement() && !consequent.node.body.length && alternate.isBlockStatement() && alternate.node.body.length) {\n            consequent.replaceWith(alternate.node);\n            alternate.remove(); // For if-statements babel-traverse replaces with an empty block\n\n            path.node.alternate = null;\n            test.replaceWith(t.unaryExpression(\"!\", test.node, true));\n          }\n        }\n\n      },\n\n      EmptyStatement(path) {\n        if (path.parentPath.isBlockStatement() || path.parentPath.isProgram()) {\n          path.remove();\n        }\n      },\n\n      Program: {\n        exit(path, {\n          opts: {\n            // set defaults\n            optimizeRawSize = false,\n            keepFnName = false,\n            keepClassName = false,\n            keepFnArgs = false,\n            tdz = false\n          } = {}\n        } = {}) {\n          (traverse.clearCache || traverse.cache.clear)();\n          path.scope.crawl();\n          markEvalScopes(path); // We need to run this plugin in isolation.\n\n          path.traverse(main, {\n            functionToBindings: new Map(),\n            optimizeRawSize,\n            keepFnName,\n            keepClassName,\n            keepFnArgs,\n            tdz\n          });\n        }\n\n      }\n    }\n  };\n\n  function toStatements(path) {\n    const node = path.node;\n\n    if (path.isBlockStatement()) {\n      let hasBlockScoped = false;\n\n      for (let i = 0; i < node.body.length; i++) {\n        const bodyNode = node.body[i];\n\n        if (t.isBlockScoped(bodyNode)) {\n          hasBlockScoped = true;\n        }\n      }\n\n      if (!hasBlockScoped) {\n        return node.body;\n      }\n    }\n\n    return [node];\n  } // Extracts vars from a path\n  // Useful for removing blocks or paths that can contain\n  // variable declarations inside them\n  // Note:\n  // drops are inits\n  // extractVars({ var x = 5, y = x }) => var x, y;\n\n\n  function extractVars(path) {\n    const declarators = [];\n\n    if (path.isVariableDeclaration({\n      kind: \"var\"\n    })) {\n      var _iterator5 = _createForOfIteratorHelper(path.node.declarations),\n          _step5;\n\n      try {\n        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {\n          const decl = _step5.value;\n          const bindingIds = Object.keys(t.getBindingIdentifiers(decl.id));\n          declarators.push(...bindingIds.map(name => t.variableDeclarator(t.identifier(name))));\n        }\n      } catch (err) {\n        _iterator5.e(err);\n      } finally {\n        _iterator5.f();\n      }\n    } else {\n      path.traverse({\n        VariableDeclaration(varPath) {\n          if (!varPath.isVariableDeclaration({\n            kind: \"var\"\n          })) return;\n          if (!isSameFunctionScope(varPath, path)) return;\n\n          var _iterator6 = _createForOfIteratorHelper(varPath.node.declarations),\n              _step6;\n\n          try {\n            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {\n              const decl = _step6.value;\n              const bindingIds = Object.keys(t.getBindingIdentifiers(decl.id));\n              declarators.push(...bindingIds.map(name => t.variableDeclarator(t.identifier(name))));\n            }\n          } catch (err) {\n            _iterator6.e(err);\n          } finally {\n            _iterator6.f();\n          }\n        }\n\n      });\n    }\n\n    if (declarators.length <= 0) return [];\n    return [t.variableDeclaration(\"var\", declarators)];\n  }\n\n  function replace(path, options) {\n    const replacement = options.replacement,\n          replacementPath = options.replacementPath,\n          scope = options.scope,\n          binding = options.binding; // Same name, different binding.\n\n    if (scope.getBinding(path.node.name) !== binding) {\n      return;\n    } // We don't want to move code around to different scopes because:\n    // 1. Original bindings that is referenced could be shadowed\n    // 2. Moving defintions to potentially hot code is bad\n\n\n    if (scope !== path.scope) {\n      if (t.isClass(replacement) || t.isFunction(replacement)) {\n        return;\n      }\n\n      let bail = false;\n      traverse(replacement, {\n        Function(path) {\n          if (bail) {\n            return;\n          }\n\n          bail = true;\n          path.stop();\n        }\n\n      }, scope);\n\n      if (bail) {\n        return;\n      }\n    } // Avoid recursion.\n\n\n    if (path.find(({\n      node\n    }) => node === replacement)) {\n      return;\n    } // https://github.com/babel/minify/issues/611\n    // this is valid only for FunctionDeclaration where we convert\n    // function declaration to expression in the next step\n\n\n    if (replacementPath.isFunctionDeclaration()) {\n      const fnName = replacementPath.get(\"id\").node.name;\n\n      for (let name in replacementPath.scope.bindings) {\n        if (name === fnName) {\n          return;\n        }\n      }\n    } // https://github.com/babel/minify/issues/130\n\n\n    if (!t.isExpression(replacement)) {\n      t.toExpression(replacement);\n    } // We don't remove fn name here, we let the FnExpr & ClassExpr visitors\n    // check its references and remove unreferenced ones\n    // if (t.isFunction(replacement)) {\n    //   replacement.id = null;\n    // }\n\n\n    path.replaceWith(replacement);\n    return true;\n  }\n\n  function updateReferences(fnToDeletePath) {\n    if (!fnToDeletePath.isFunction()) {\n      return;\n    }\n\n    fnToDeletePath.traverse({\n      ReferencedIdentifier(path) {\n        const node = path.node,\n              scope = path.scope;\n        const binding = scope.getBinding(node.name);\n\n        if (!binding || !binding.path.isFunction() || binding.scope === scope || !binding.constant) {\n          return;\n        }\n\n        const index = binding.referencePaths.indexOf(path);\n\n        if (index === -1) {\n          return;\n        }\n\n        binding.references--;\n        binding.referencePaths.splice(index, 1);\n\n        if (binding.references === 0) {\n          binding.referenced = false;\n        }\n\n        if (binding.references <= 1 && binding.scope.path.node) {\n          binding.scope.path.node[shouldRevisit] = true;\n        }\n      }\n\n    });\n  }\n\n  function removeUnreferencedId(path) {\n    const id = path.get(\"id\").node;\n\n    if (!id) {\n      return;\n    }\n\n    const node = path.node,\n          scope = path.scope;\n    const binding = scope.getBinding(id.name); // Check if shadowed or is not referenced.\n\n    if (binding && (binding.path.node !== node || !binding.referenced)) {\n      node.id = null;\n    }\n  } // path1 -> path2\n  // is path1 an ancestor of path2\n\n\n  function isAncestor(path1, path2) {\n    return !!path2.findParent(parent => parent === path1);\n  }\n\n  function isSameFunctionScope(path1, path2) {\n    return path1.scope.getFunctionParent() === path2.scope.getFunctionParent();\n  }\n\n  function isBreaking(stmt, path) {\n    return isControlTransfer(stmt, path, \"break\");\n  }\n\n  function isContinuing(stmt, path) {\n    return isControlTransfer(stmt, path, \"continue\");\n  } // tells if a \"stmt\" is a break/continue statement\n\n\n  function isControlTransfer(stmt, path, control = \"break\") {\n    const _break$continue = {\n      break: \"BreakStatement\",\n      continue: \"ContinueStatement\"\n    },\n          type = _break$continue[control];\n\n    if (!type) {\n      throw new Error(\"Can only handle break and continue statements\");\n    }\n\n    const checker = `is${type}`;\n\n    if (stmt[checker]()) {\n      return _isControlTransfer(stmt, path);\n    }\n\n    let isTransferred = false;\n    let result = {\n      [control]: false,\n      bail: false\n    };\n    stmt.traverse({\n      [type](cPath) {\n        // if we already detected a break/continue statement,\n        if (isTransferred) return;\n        result = _isControlTransfer(cPath, path);\n\n        if (result.bail || result[control]) {\n          isTransferred = true;\n        }\n      }\n\n    });\n    return result;\n\n    function _isControlTransfer(cPath, path) {\n      const label = cPath.get(\"label\");\n\n      if (label.node !== null) {\n        // labels are fn scoped and not accessible by inner functions\n        // path is the switch statement\n        if (!isSameFunctionScope(path, cPath)) {\n          // we don't have to worry about this break statement\n          return {\n            break: false,\n            bail: false\n          };\n        } // here we handle the break labels\n        // if they are outside switch, we bail out\n        // if they are within the case, we keep them\n\n\n        let labelPath;\n\n        if (path.scope.getLabel) {\n          labelPath = getLabel(label.node.name, path);\n        } else {\n          labelPath = path.scope.getBinding(label.node.name).path;\n        }\n\n        const _isAncestor = isAncestor(labelPath, path);\n\n        return {\n          bail: _isAncestor,\n          [control]: _isAncestor\n        };\n      } // set the flag that it is indeed breaking\n\n\n      let isCTransfer = true; // this flag is to capture\n      // switch(0) { case 0: while(1) if (x) break; }\n\n      let possibleRunTimeControlTransfer = false; // and compute if it's breaking the correct thing\n\n      let parent = cPath.parentPath;\n\n      while (parent !== stmt.parentPath) {\n        // loops and nested switch cases\n        if (parent.isLoop() || parent.isSwitchCase()) {\n          // invalidate all the possible runtime breaks captured\n          // while (1) { if (x) break; }\n          possibleRunTimeControlTransfer = false; // and set that it's not breaking our switch statement\n\n          isCTransfer = false;\n          break;\n        } //\n        // this is a special case and depends on\n        // the fact that SwitchStatement is handled in the\n        // exit hook of the traverse\n        //\n        // switch (0) {\n        //   case 0: if (x) break;\n        // }\n        //\n        // here `x` is runtime only.\n        // in this case, we need to bail out. So we depend on exit hook\n        // of switch so that, it would have visited the IfStatement first\n        // before the SwitchStatement and would have removed the\n        // IfStatement if it was a compile time determined\n        //\n\n\n        if (parent.isIfStatement()) {\n          possibleRunTimeControlTransfer = true;\n        }\n\n        parent = parent.parentPath;\n      }\n\n      return {\n        [control]: possibleRunTimeControlTransfer || isCTransfer,\n        bail: possibleRunTimeControlTransfer\n      };\n    }\n  } // things that are hoisted\n\n\n  function canExistAfterCompletion(path) {\n    return path.isFunctionDeclaration() || path.isVariableDeclaration({\n      kind: \"var\"\n    });\n  }\n\n  function getLabel(name, _path) {\n    let label,\n        path = _path;\n\n    do {\n      label = path.scope.getLabel(name);\n\n      if (label) {\n        return label;\n      }\n    } while (path = path.parentPath);\n\n    return null;\n  }\n\n  function hasLoopParent(path) {\n    let parent = path;\n\n    do {\n      if (parent.isLoop()) {\n        return true;\n      }\n    } while (parent = parent.parentPath);\n\n    return false;\n  }\n\n  function extractSequenceImpure(seq) {\n    const expressions = seq.get(\"expressions\");\n    const result = [];\n\n    for (let i = 0; i < expressions.length; i++) {\n      if (!expressions[i].isPure()) {\n        result.push(expressions[i].node);\n      }\n    }\n\n    return t.sequenceExpression(result);\n  }\n};","\"use strict\";\n\nconst CountedSet = require(\"./counted-set\");\n\nconst isLabelIdentifier = require(\"./is-label-identifier\");\n\nconst newIssueUrl = \"https://github.com/babel/minify/issues/new\";\n/**\n * ScopeTracker\n *   references: Map<Scope, CountedSet<String> >\n *   bindings: Map<Scope, Map<String, Binding> >\n */\n\nmodule.exports = class ScopeTracker {\n  constructor() {\n    this.references = new Map();\n    this.bindings = new Map();\n  }\n  /**\n   * Register a new Scope and initiliaze it with empty sets\n   * @param {Scope} scope\n   */\n\n\n  addScope(scope) {\n    if (!this.references.has(scope)) {\n      this.references.set(scope, new CountedSet());\n    }\n\n    if (!this.bindings.has(scope)) {\n      this.bindings.set(scope, new Map());\n    }\n  }\n  /**\n   * Add reference to all Scopes between and including the ReferencedScope\n   * and Binding's Scope\n   * @param {Scope} scope\n   * @param {Binding} binding\n   * @param {String} name\n   */\n\n\n  addReference(scope, binding, name) {\n    let parent = scope;\n\n    do {\n      this.references.get(parent).add(name);\n\n      if (!binding) {\n        throw new Error(`Binding Not Found for ${name} during scopeTracker.addRefernce. ` + `Please report at ${newIssueUrl}`);\n      }\n\n      if (binding.scope === parent) break;\n    } while (parent = parent.parent);\n  }\n  /**\n   * has a Reference in the given {Scope} or a child Scope\n   *\n   * Refer {addReference} to know why the following call will be valid\n   * for detecting references in child Scopes\n   *\n   * @param {Scope} scope\n   * @param {String} name\n   */\n\n\n  hasReference(scope, name) {\n    return this.references.get(scope).has(name);\n  }\n  /**\n   * Update reference count in all scopes between and including the\n   * Referenced Scope and the Binding's Scope\n   *\n   * @param {Scope} scope\n   * @param {Binding} binding\n   * @param {String} oldName\n   * @param {String} newName\n   */\n\n\n  updateReference(scope, binding, oldName, newName) {\n    let parent = scope;\n\n    do {\n      const ref = this.references.get(parent);\n      ref.delete(oldName);\n      ref.add(newName);\n\n      if (!binding) {\n        // Something went wrong - panic\n        throw new Error(\"Binding Not Found during scopeTracker.updateRefernce \" + `while updating \"${oldName}\" to \"${newName}\". ` + `Please report at ${newIssueUrl}`);\n      }\n\n      if (binding.scope === parent) break;\n    } while (parent = parent.parent);\n  }\n  /**\n   * has either a Binding or a Reference\n   * @param {Scope} scope\n   * @param {Binding} binding\n   * @param {String} name\n   */\n\n\n  hasBindingOrReference(scope, binding, name) {\n    return this.hasReference(scope, name) || this.hasBinding(scope, name);\n  }\n  /**\n   * For a Binding visit all places where the Binding is used and detect\n   * if the newName {next} can be used in all these places\n   *\n   * 1. binding's own scope\n   * 2. constant violations' scopes\n   * 3. referencePaths' scopes\n   *\n   * @param {Binding} binding\n   * @param {String} next\n   */\n\n\n  canUseInReferencedScopes(binding, next) {\n    const tracker = this;\n\n    if (tracker.hasBindingOrReference(binding.scope, binding, next)) {\n      return false;\n    } // Safari raises a syntax error for a `let` or `const` declaration in a\n    // `for` loop initialization that shadows a parent function's parameter.\n    // https://github.com/babel/minify/issues/559\n    // https://bugs.webkit.org/show_bug.cgi?id=171041\n    // https://trac.webkit.org/changeset/217200/webkit/trunk/Source\n\n\n    const maybeDecl = binding.path.parentPath;\n    const isBlockScoped = maybeDecl.isVariableDeclaration({\n      kind: \"let\"\n    }) || maybeDecl.isVariableDeclaration({\n      kind: \"const\"\n    });\n\n    if (isBlockScoped) {\n      const maybeFor = maybeDecl.parentPath;\n      const isForLoopBinding = maybeFor.isForStatement({\n        init: maybeDecl.node\n      }) || maybeFor.isForXStatement({\n        left: maybeDecl.node\n      });\n\n      if (isForLoopBinding) {\n        const fnParent = getFunctionParent(maybeFor);\n\n        if (fnParent.isFunction({\n          body: maybeFor.parent\n        })) {\n          const parentFunctionBinding = this.bindings.get(fnParent.scope).get(next);\n\n          if (parentFunctionBinding) {\n            const parentFunctionHasParamBinding = parentFunctionBinding.kind === \"param\";\n\n            if (parentFunctionHasParamBinding) {\n              return false;\n            }\n          }\n        }\n      }\n    }\n\n    for (let i = 0; i < binding.constantViolations.length; i++) {\n      const violation = binding.constantViolations[i];\n\n      if (tracker.hasBindingOrReference(violation.scope, binding, next)) {\n        return false;\n      }\n    }\n\n    for (let i = 0; i < binding.referencePaths.length; i++) {\n      const ref = binding.referencePaths[i];\n\n      if (!ref.isIdentifier()) {\n        let canUse = true;\n        ref.traverse({\n          ReferencedIdentifier(path) {\n            if (path.node.name !== next) return;\n\n            if (tracker.hasBindingOrReference(path.scope, binding, next)) {\n              canUse = false;\n            }\n          }\n\n        });\n\n        if (!canUse) {\n          return canUse;\n        }\n      } else if (!isLabelIdentifier(ref)) {\n        if (tracker.hasBindingOrReference(ref.scope, binding, next)) {\n          return false;\n        }\n      }\n    }\n\n    return true;\n  }\n  /**\n   * Add a binding to Tracker in binding's own Scope\n   * @param {Binding} binding\n   */\n\n\n  addBinding(binding) {\n    if (!binding) {\n      return;\n    }\n\n    const bindings = this.bindings.get(binding.scope);\n    const existingBinding = bindings.get(binding.identifier.name);\n\n    if (existingBinding && existingBinding !== binding) {\n      throw new Error(`scopeTracker.addBinding: ` + `Binding \"${existingBinding.identifier.name}\" already exists. ` + `Trying to add \"${binding.identifier.name}\" again.`);\n    }\n\n    bindings.set(binding.identifier.name, binding);\n  }\n  /**\n   * Moves Binding from it's own Scope to {@param toScope}\n   *\n   * required for fixup-var-scope\n   *\n   * @param {Binding} binding\n   * @param {Scope} toScope\n   */\n\n\n  moveBinding(binding, toScope) {\n    this.bindings.get(binding.scope).delete(binding.identifier.name);\n    this.bindings.get(toScope).set(binding.identifier.name, binding);\n  }\n  /**\n   * has a Binding in the current {Scope}\n   * @param {Scope} scope\n   * @param {String} name\n   */\n\n\n  hasBinding(scope, name) {\n    return this.bindings.get(scope).has(name);\n  }\n  /**\n   * Update the ScopeTracker on rename\n   * @param {Scope} scope\n   * @param {String} oldName\n   * @param {String} newName\n   */\n\n\n  renameBinding(scope, oldName, newName) {\n    const bindings = this.bindings.get(scope);\n    bindings.set(newName, bindings.get(oldName));\n    bindings.delete(oldName);\n  }\n\n};\n/**\n * Babel-7 returns null if there is no function parent\n * and uses getProgramParent to get Program\n */\n\nfunction getFunctionParent(path) {\n  return (path.scope.getFunctionParent() || path.scope.getProgramParent()).path;\n}","/*\n  Copyright (C) 2013 Yusuke Suzuki <utatane.tea@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n(function () {\n    'use strict';\n\n    function isExpression(node) {\n        if (node == null) { return false; }\n        switch (node.type) {\n            case 'ArrayExpression':\n            case 'AssignmentExpression':\n            case 'BinaryExpression':\n            case 'CallExpression':\n            case 'ConditionalExpression':\n            case 'FunctionExpression':\n            case 'Identifier':\n            case 'Literal':\n            case 'LogicalExpression':\n            case 'MemberExpression':\n            case 'NewExpression':\n            case 'ObjectExpression':\n            case 'SequenceExpression':\n            case 'ThisExpression':\n            case 'UnaryExpression':\n            case 'UpdateExpression':\n                return true;\n        }\n        return false;\n    }\n\n    function isIterationStatement(node) {\n        if (node == null) { return false; }\n        switch (node.type) {\n            case 'DoWhileStatement':\n            case 'ForInStatement':\n            case 'ForStatement':\n            case 'WhileStatement':\n                return true;\n        }\n        return false;\n    }\n\n    function isStatement(node) {\n        if (node == null) { return false; }\n        switch (node.type) {\n            case 'BlockStatement':\n            case 'BreakStatement':\n            case 'ContinueStatement':\n            case 'DebuggerStatement':\n            case 'DoWhileStatement':\n            case 'EmptyStatement':\n            case 'ExpressionStatement':\n            case 'ForInStatement':\n            case 'ForStatement':\n            case 'IfStatement':\n            case 'LabeledStatement':\n            case 'ReturnStatement':\n            case 'SwitchStatement':\n            case 'ThrowStatement':\n            case 'TryStatement':\n            case 'VariableDeclaration':\n            case 'WhileStatement':\n            case 'WithStatement':\n                return true;\n        }\n        return false;\n    }\n\n    function isSourceElement(node) {\n      return isStatement(node) || node != null && node.type === 'FunctionDeclaration';\n    }\n\n    function trailingStatement(node) {\n        switch (node.type) {\n        case 'IfStatement':\n            if (node.alternate != null) {\n                return node.alternate;\n            }\n            return node.consequent;\n\n        case 'LabeledStatement':\n        case 'ForStatement':\n        case 'ForInStatement':\n        case 'WhileStatement':\n        case 'WithStatement':\n            return node.body;\n        }\n        return null;\n    }\n\n    function isProblematicIfStatement(node) {\n        var current;\n\n        if (node.type !== 'IfStatement') {\n            return false;\n        }\n        if (node.alternate == null) {\n            return false;\n        }\n        current = node.consequent;\n        do {\n            if (current.type === 'IfStatement') {\n                if (current.alternate == null)  {\n                    return true;\n                }\n            }\n            current = trailingStatement(current);\n        } while (current);\n\n        return false;\n    }\n\n    module.exports = {\n        isExpression: isExpression,\n        isStatement: isStatement,\n        isIterationStatement: isIterationStatement,\n        isSourceElement: isSourceElement,\n        isProblematicIfStatement: isProblematicIfStatement,\n\n        trailingStatement: trailingStatement\n    };\n}());\n/* vim: set sw=4 ts=4 et tw=80 : */\n","\"use strict\";\n\nmodule.exports = function ({\n  types: t\n}) {\n  const isVoid0 = require(\"babel-helper-is-void-0\")(t);\n\n  return {\n    name: \"minify-flip-comparisons\",\n    visitor: {\n      // flip comparisons with a pure right hand value, this ensures\n      // consistency with comparisons and increases the length of\n      // strings that gzip can match\n      // typeof blah === 'function' -> 'function' === typeof blah\n      BinaryExpression(path) {\n        const node = path.node;\n        const right = node.right,\n              left = node.left; // Make sure we have a constant on the right.\n\n        if (!t.isLiteral(right) && !isVoid0(right) && !(t.isUnaryExpression(right) && t.isLiteral(right.argument)) && !t.isObjectExpression(right) && !t.isArrayExpression(right)) {\n          return;\n        } // Commutative operators.\n\n\n        if (t.EQUALITY_BINARY_OPERATORS.indexOf(node.operator) >= 0 || [\"*\", \"^\", \"&\", \"|\"].indexOf(node.operator) >= 0) {\n          node.left = right;\n          node.right = left;\n          return;\n        }\n\n        if (t.BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(node.operator) >= 0) {\n          node.left = right;\n          node.right = left;\n          let operator;\n\n          switch (node.operator) {\n            case \">\":\n              operator = \"<\";\n              break;\n\n            case \"<\":\n              operator = \">\";\n              break;\n\n            case \">=\":\n              operator = \"<=\";\n              break;\n\n            case \"<=\":\n              operator = \">=\";\n              break;\n          }\n\n          node.operator = operator;\n          return;\n        }\n      }\n\n    }\n  };\n};","\"use strict\";\n\nfunction createRegExpLiteral(args, prettify, t) {\n  const evaluatedArgs = args.map(a => a.evaluate());\n\n  if (!evaluatedArgs.every(a => a.confident && typeof a.value === \"string\")) {\n    return;\n  }\n\n  let pattern = evaluatedArgs.length >= 1 && evaluatedArgs[0].value !== \"\" ? evaluatedArgs[0].value : \"(?:)\";\n  const flags = evaluatedArgs.length >= 2 ? evaluatedArgs[1].value : \"\";\n  pattern = new RegExp(pattern).source;\n\n  if (prettify) {\n    pattern = pattern.replace(/\\n/g, \"\\\\n\").replace(/\\u2028/g, \"\\\\u2028\").replace(/\\u2029/g, \"\\\\u2029\").replace(/[\\b]/g, \"[\\\\b]\").replace(/\\v/g, \"\\\\v\").replace(/\\f/g, \"\\\\f\").replace(/\\r/g, \"\\\\r\");\n  }\n\n  pattern = pattern.replace(/\\0/g, \"\\\\0\");\n  return t.regExpLiteral(pattern, flags);\n}\n\nfunction maybeReplaceWithRegExpLiteral(path, t) {\n  if (!t.isIdentifier(path.node.callee, {\n    name: \"RegExp\"\n  })) {\n    return;\n  }\n\n  const regExpLiteral = createRegExpLiteral(path.get(\"arguments\"), true, t);\n\n  if (regExpLiteral) {\n    path.replaceWith(regExpLiteral);\n  }\n}\n\nmodule.exports = function ({\n  types: t\n}) {\n  return {\n    name: \"transform-regexp-constructors\",\n    visitor: {\n      NewExpression(path) {\n        maybeReplaceWithRegExpLiteral(path, t);\n      },\n\n      CallExpression(path) {\n        // equivalent to `new RegExp()` according to §21.2.3\n        maybeReplaceWithRegExpLiteral(path, t);\n      }\n\n    }\n  };\n};","var baseIsEqual = require('./_baseIsEqual'),\n    get = require('./get'),\n    hasIn = require('./hasIn'),\n    isKey = require('./_isKey'),\n    isStrictComparable = require('./_isStrictComparable'),\n    matchesStrictComparable = require('./_matchesStrictComparable'),\n    toKey = require('./_toKey');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n *\n * @private\n * @param {string} path The path of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction baseMatchesProperty(path, srcValue) {\n  if (isKey(path) && isStrictComparable(srcValue)) {\n    return matchesStrictComparable(toKey(path), srcValue);\n  }\n  return function(object) {\n    var objValue = get(object, path);\n    return (objValue === undefined && objValue === srcValue)\n      ? hasIn(object, path)\n      : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n  };\n}\n\nmodule.exports = baseMatchesProperty;\n","var memoizeCapped = require('./_memoizeCapped');\n\n/** Used to match property names within property paths. */\nvar rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\nvar stringToPath = memoizeCapped(function(string) {\n  var result = [];\n  if (string.charCodeAt(0) === 46 /* . */) {\n    result.push('');\n  }\n  string.replace(rePropName, function(match, number, quote, subString) {\n    result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n  });\n  return result;\n});\n\nmodule.exports = stringToPath;\n","\"use strict\";\n\nconst CHARSET = (\"abcdefghijklmnopqrstuvwxyz\" + \"ABCDEFGHIJKLMNOPQRSTUVWXYZ$_\").split(\"\");\nmodule.exports = class Charset {\n  constructor(shouldConsider) {\n    this.shouldConsider = shouldConsider;\n    this.chars = CHARSET.slice();\n    this.frequency = {};\n    this.chars.forEach(c => {\n      this.frequency[c] = 0;\n    });\n    this.finalized = false;\n  }\n\n  consider(str) {\n    if (!this.shouldConsider) {\n      return;\n    }\n\n    str.split(\"\").forEach(c => {\n      if (this.frequency[c] != null) {\n        this.frequency[c]++;\n      }\n    });\n  }\n\n  sort() {\n    if (this.shouldConsider) {\n      this.chars = this.chars.sort((a, b) => this.frequency[b] - this.frequency[a]);\n    }\n\n    this.finalized = true;\n  }\n\n  getIdentifier(num) {\n    if (!this.finalized) {\n      throw new Error(\"Should sort first\");\n    }\n\n    let ret = \"\";\n    num++;\n\n    do {\n      num--;\n      ret += this.chars[num % this.chars.length];\n      num = Math.floor(num / this.chars.length);\n    } while (num > 0);\n\n    return ret;\n  }\n\n};","\"use strict\";\n\nmodule.exports = function ({\n  types: t\n}) {\n  // custom implementation of getTypeAnnotation that fixes\n  // the type information that is lost during sequence expression transformation\n  // https://github.com/babel/minify/issues/323\n  function customTypeAnnotation(path) {\n    if (path.typeAnnotation) {\n      return path.typeAnnotation;\n    } // We are not handling the case of literals and other base types\n    // since they are already handled via getTypeAnnotation\n\n\n    const node = path.node;\n    const binding = path.parentPath.scope.getBinding(node.name);\n    const types = [];\n\n    if (binding && binding.constantViolations) {\n      if (binding.identifier.typeAnnotation) {\n        return binding.identifier.typeAnnotation;\n      }\n\n      if (binding.constantViolations) {\n        const violations = binding.constantViolations;\n        var _iteratorNormalCompletion = true;\n        var _didIteratorError = false;\n        var _iteratorError = undefined;\n\n        try {\n          for (var _iterator = violations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n            let violation = _step.value;\n            types.push(violation.getTypeAnnotation());\n          }\n        } catch (err) {\n          _didIteratorError = true;\n          _iteratorError = err;\n        } finally {\n          try {\n            if (!_iteratorNormalCompletion && _iterator.return != null) {\n              _iterator.return();\n            }\n          } finally {\n            if (_didIteratorError) {\n              throw _iteratorError;\n            }\n          }\n        }\n      }\n    }\n\n    if (types.length > 0) {\n      return t.createUnionTypeAnnotation(types);\n    }\n\n    return types;\n  } // Based on the type inference in Babel\n\n\n  function baseTypeStrictlyMatches(left, right) {\n    let leftTypes, rightTypes;\n\n    if (t.isIdentifier(left)) {\n      leftTypes = customTypeAnnotation(left);\n    } else if (t.isIdentifier(right)) {\n      rightTypes = customTypeAnnotation(right);\n    } // Early exit\n\n\n    if (t.isAnyTypeAnnotation(leftTypes) || t.isAnyTypeAnnotation(rightTypes)) {\n      return false;\n    }\n\n    leftTypes = [].concat(leftTypes, left.getTypeAnnotation());\n    rightTypes = [].concat(rightTypes, right.getTypeAnnotation());\n    leftTypes = t.createUnionTypeAnnotation(leftTypes);\n    rightTypes = t.createUnionTypeAnnotation(rightTypes);\n\n    if (!t.isAnyTypeAnnotation(leftTypes) && t.isFlowBaseAnnotation(leftTypes)) {\n      return leftTypes.type === rightTypes.type;\n    }\n  }\n\n  return {\n    name: \"transform-simplify-comparison-operators\",\n    visitor: {\n      // simplify comparison operations if we're 100% certain\n      // that each value will always be of the same type\n      BinaryExpression(path) {\n        const node = path.node;\n        const op = node.operator;\n\n        if (op !== \"===\" && op !== \"!==\") {\n          return;\n        }\n\n        const left = path.get(\"left\");\n        const right = path.get(\"right\");\n        const strictMatch = baseTypeStrictlyMatches(left, right);\n\n        if (strictMatch) {\n          node.operator = node.operator.slice(0, -1);\n        }\n      }\n\n    }\n  };\n};","\"use strict\";\n\nconst h = require(\"./helpers\");\n\nconst PatternMatch = require(\"./pattern-match\");\n\nmodule.exports = t => {\n  // small abstractions\n  const not = node => t.unaryExpression(\"!\", node);\n\n  const notnot = node => not(not(node));\n\n  const or = (a, b) => t.logicalExpression(\"||\", a, b);\n\n  const and = (a, b) => t.logicalExpression(\"&&\", a, b);\n\n  function simplifyPatterns(path) {\n    const test = path.get(\"test\");\n    const consequent = path.get(\"consequent\");\n    const alternate = path.get(\"alternate\");\n\n    const _h$typeSymbols = h.typeSymbols(t),\n          EX = _h$typeSymbols.Expression; // Convention:\n    // ===============\n    // for each pattern [test, consequent, alternate, handler(expr, cons, alt)]\n\n\n    const matcher = new PatternMatch([[EX, true, false, e => notnot(e)], [EX, false, true, e => not(e)], [EX, true, EX, (e, c, a) => or(notnot(e), a)], [EX, false, EX, (e, c, a) => and(not(e), a)], [EX, EX, true, (e, c) => or(not(e), c)], [EX, EX, false, (e, c) => and(notnot(e), c)]]);\n    const result = matcher.match([test, consequent, alternate], h.isPatternMatchesPath(t));\n\n    if (result.match) {\n      path.replaceWith(result.value(test.node, consequent.node, alternate.node));\n    }\n  }\n\n  return {\n    simplifyPatterns\n  };\n};","\"use strict\";\n\nmodule.exports = function (t) {\n  // If we can't remove the expression we'll just replace it with an empty statement.\n  function removeOrVoid(path) {\n    // If we are working with the expression of an expression statement we want to deal\n    // with the expression statement instead.\n    if (path.parentPath.isExpressionStatement({\n      expression: path.node\n    })) {\n      path = path.parentPath;\n    } // If we are working with a variable declarator and there is only one then\n    // we need to look at the parent.\n\n\n    if (path.isVariableDeclarator() && path.parent.declarations[0] === path.node && path.parent.declarations.length === 1) {\n      path = path.parentPath;\n    }\n\n    if (!path.inList && path.scope.path.type !== \"ForStatement\") {\n      path.replaceWith(t.emptyStatement());\n    } else {\n      path.remove();\n    }\n  }\n\n  return removeOrVoid;\n};","var Symbol = require('./_Symbol'),\n    Uint8Array = require('./_Uint8Array'),\n    eq = require('./eq'),\n    equalArrays = require('./_equalArrays'),\n    mapToArray = require('./_mapToArray'),\n    setToArray = require('./_setToArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]';\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n  switch (tag) {\n    case dataViewTag:\n      if ((object.byteLength != other.byteLength) ||\n          (object.byteOffset != other.byteOffset)) {\n        return false;\n      }\n      object = object.buffer;\n      other = other.buffer;\n\n    case arrayBufferTag:\n      if ((object.byteLength != other.byteLength) ||\n          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n        return false;\n      }\n      return true;\n\n    case boolTag:\n    case dateTag:\n    case numberTag:\n      // Coerce booleans to `1` or `0` and dates to milliseconds.\n      // Invalid dates are coerced to `NaN`.\n      return eq(+object, +other);\n\n    case errorTag:\n      return object.name == other.name && object.message == other.message;\n\n    case regexpTag:\n    case stringTag:\n      // Coerce regexes to strings and treat strings, primitives and objects,\n      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n      // for more details.\n      return object == (other + '');\n\n    case mapTag:\n      var convert = mapToArray;\n\n    case setTag:\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n      convert || (convert = setToArray);\n\n      if (object.size != other.size && !isPartial) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked) {\n        return stacked == other;\n      }\n      bitmask |= COMPARE_UNORDERED_FLAG;\n\n      // Recursively compare objects (susceptible to call stack limits).\n      stack.set(object, other);\n      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n      stack['delete'](object);\n      return result;\n\n    case symbolTag:\n      if (symbolValueOf) {\n        return symbolValueOf.call(object) == symbolValueOf.call(other);\n      }\n  }\n  return false;\n}\n\nmodule.exports = equalByTag;\n","/**\n * A specialized version of `matchesProperty` for source values suitable\n * for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction matchesStrictComparable(key, srcValue) {\n  return function(object) {\n    if (object == null) {\n      return false;\n    }\n    return object[key] === srcValue &&\n      (srcValue !== undefined || (key in Object(object)));\n  };\n}\n\nmodule.exports = matchesStrictComparable;\n","var memoize = require('./memoize');\n\n/** Used as the maximum memoize cache size. */\nvar MAX_MEMOIZE_SIZE = 500;\n\n/**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\nfunction memoizeCapped(func) {\n  var result = memoize(func, function(key) {\n    if (cache.size === MAX_MEMOIZE_SIZE) {\n      cache.clear();\n    }\n    return key;\n  });\n\n  var cache = result.cache;\n  return result;\n}\n\nmodule.exports = memoizeCapped;\n","var baseFor = require('./_baseFor'),\n    keys = require('./keys');\n\n/**\n * The base implementation of `_.forOwn` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Object} Returns `object`.\n */\nfunction baseForOwn(object, iteratee) {\n  return object && baseFor(object, iteratee, keys);\n}\n\nmodule.exports = baseForOwn;\n","\"use strict\";\n\n// this fixes a bug where converting let to var\n// doesn't change the binding's scope to function scope\n// https://github.com/babel/babel/issues/4818\nmodule.exports = function (mangler) {\n  mangler.program.traverse({\n    VariableDeclaration(path) {\n      if (path.node.kind !== \"var\") {\n        return;\n      }\n\n      const fnScope = path.scope.getFunctionParent() || path.scope.getProgramParent();\n      const bindingIds = path.getOuterBindingIdentifierPaths();\n\n      for (const name in bindingIds) {\n        const binding = path.scope.getBinding(name); // var isn't hoisted to fnScope\n\n        if (binding.scope !== fnScope) {\n          const existingBinding = fnScope.bindings[name]; // make sure we are clear that the fnScope doesn't already have\n          // an existing binding\n\n          if (!existingBinding) {\n            // move binding to the function scope\n            // update our scopeTracker first before\n            // we mutate the scope\n            mangler.scopeTracker.moveBinding(binding, fnScope);\n            fnScope.bindings[name] = binding;\n            binding.scope = fnScope;\n            delete binding.scope.bindings[name];\n          } else {\n            // we need a new binding that's valid in both the scopes\n            // binding.scope and fnScope\n            const newName = fnScope.generateUid(binding.scope.generateUid(name)); // rename binding in the original scope\n\n            mangler.rename(binding.scope, binding, name, newName); // move binding to fnScope as newName\n            // update our scopeTracker first before\n            // we mutate the scope\n\n            mangler.scopeTracker.moveBinding(binding, fnScope);\n            fnScope.bindings[newName] = binding;\n            binding.scope = fnScope;\n            delete binding.scope.bindings[newName];\n          }\n        }\n      }\n    }\n\n  });\n};","/**\n * The base implementation of `_.hasIn` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\nfunction baseHasIn(object, key) {\n  return object != null && key in Object(object);\n}\n\nmodule.exports = baseHasIn;\n","/*\n  Copyright (C) 2013-2014 Yusuke Suzuki <utatane.tea@gmail.com>\n  Copyright (C) 2014 Ivan Nikulin <ifaaan@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n(function () {\n    'use strict';\n\n    var ES6Regex, ES5Regex, NON_ASCII_WHITESPACES, IDENTIFIER_START, IDENTIFIER_PART, ch;\n\n    // See `tools/generate-identifier-regex.js`.\n    ES5Regex = {\n        // ECMAScript 5.1/Unicode v9.0.0 NonAsciiIdentifierStart:\n        NonAsciiIdentifierStart: /[\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B4\\u08B6-\\u08BD\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u1884\\u1887-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1C80-\\u1C88\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AE\\uA7B0-\\uA7B7\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]/,\n        // ECMAScript 5.1/Unicode v9.0.0 NonAsciiIdentifierPart:\n        NonAsciiIdentifierPart: /[\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0300-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u0483-\\u0487\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0610-\\u061A\\u0620-\\u0669\\u066E-\\u06D3\\u06D5-\\u06DC\\u06DF-\\u06E8\\u06EA-\\u06FC\\u06FF\\u0710-\\u074A\\u074D-\\u07B1\\u07C0-\\u07F5\\u07FA\\u0800-\\u082D\\u0840-\\u085B\\u08A0-\\u08B4\\u08B6-\\u08BD\\u08D4-\\u08E1\\u08E3-\\u0963\\u0966-\\u096F\\u0971-\\u0983\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BC-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CE\\u09D7\\u09DC\\u09DD\\u09DF-\\u09E3\\u09E6-\\u09F1\\u0A01-\\u0A03\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A59-\\u0A5C\\u0A5E\\u0A66-\\u0A75\\u0A81-\\u0A83\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABC-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AD0\\u0AE0-\\u0AE3\\u0AE6-\\u0AEF\\u0AF9\\u0B01-\\u0B03\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3C-\\u0B44\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B5C\\u0B5D\\u0B5F-\\u0B63\\u0B66-\\u0B6F\\u0B71\\u0B82\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD0\\u0BD7\\u0BE6-\\u0BEF\\u0C00-\\u0C03\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C58-\\u0C5A\\u0C60-\\u0C63\\u0C66-\\u0C6F\\u0C80-\\u0C83\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBC-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CDE\\u0CE0-\\u0CE3\\u0CE6-\\u0CEF\\u0CF1\\u0CF2\\u0D01-\\u0D03\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D-\\u0D44\\u0D46-\\u0D48\\u0D4A-\\u0D4E\\u0D54-\\u0D57\\u0D5F-\\u0D63\\u0D66-\\u0D6F\\u0D7A-\\u0D7F\\u0D82\\u0D83\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDF\\u0DE6-\\u0DEF\\u0DF2\\u0DF3\\u0E01-\\u0E3A\\u0E40-\\u0E4E\\u0E50-\\u0E59\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB9\\u0EBB-\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EC8-\\u0ECD\\u0ED0-\\u0ED9\\u0EDC-\\u0EDF\\u0F00\\u0F18\\u0F19\\u0F20-\\u0F29\\u0F35\\u0F37\\u0F39\\u0F3E-\\u0F47\\u0F49-\\u0F6C\\u0F71-\\u0F84\\u0F86-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u1000-\\u1049\\u1050-\\u109D\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u135D-\\u135F\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1714\\u1720-\\u1734\\u1740-\\u1753\\u1760-\\u176C\\u176E-\\u1770\\u1772\\u1773\\u1780-\\u17D3\\u17D7\\u17DC\\u17DD\\u17E0-\\u17E9\\u180B-\\u180D\\u1810-\\u1819\\u1820-\\u1877\\u1880-\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1920-\\u192B\\u1930-\\u193B\\u1946-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u19D0-\\u19D9\\u1A00-\\u1A1B\\u1A20-\\u1A5E\\u1A60-\\u1A7C\\u1A7F-\\u1A89\\u1A90-\\u1A99\\u1AA7\\u1AB0-\\u1ABD\\u1B00-\\u1B4B\\u1B50-\\u1B59\\u1B6B-\\u1B73\\u1B80-\\u1BF3\\u1C00-\\u1C37\\u1C40-\\u1C49\\u1C4D-\\u1C7D\\u1C80-\\u1C88\\u1CD0-\\u1CD2\\u1CD4-\\u1CF6\\u1CF8\\u1CF9\\u1D00-\\u1DF5\\u1DFB-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u200C\\u200D\\u203F\\u2040\\u2054\\u2071\\u207F\\u2090-\\u209C\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D7F-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2DE0-\\u2DFF\\u2E2F\\u3005-\\u3007\\u3021-\\u302F\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u3099\\u309A\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA62B\\uA640-\\uA66F\\uA674-\\uA67D\\uA67F-\\uA6F1\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AE\\uA7B0-\\uA7B7\\uA7F7-\\uA827\\uA840-\\uA873\\uA880-\\uA8C5\\uA8D0-\\uA8D9\\uA8E0-\\uA8F7\\uA8FB\\uA8FD\\uA900-\\uA92D\\uA930-\\uA953\\uA960-\\uA97C\\uA980-\\uA9C0\\uA9CF-\\uA9D9\\uA9E0-\\uA9FE\\uAA00-\\uAA36\\uAA40-\\uAA4D\\uAA50-\\uAA59\\uAA60-\\uAA76\\uAA7A-\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEF\\uAAF2-\\uAAF6\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABEA\\uABEC\\uABED\\uABF0-\\uABF9\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE00-\\uFE0F\\uFE20-\\uFE2F\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF10-\\uFF19\\uFF21-\\uFF3A\\uFF3F\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]/\n    };\n\n    ES6Regex = {\n        // ECMAScript 6/Unicode v9.0.0 NonAsciiIdentifierStart:\n        NonAsciiIdentifierStart: /[\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0-\\u08B4\\u08B6-\\u08BD\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1C80-\\u1C88\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2118-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309B-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AE\\uA7B0-\\uA7B7\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDD40-\\uDD74\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDF00-\\uDF1F\\uDF30-\\uDF4A\\uDF50-\\uDF75\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF\\uDFD1-\\uDFD5]|\\uD801[\\uDC00-\\uDC9D\\uDCB0-\\uDCD3\\uDCD8-\\uDCFB\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00\\uDE10-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE33\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE4\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48\\uDC80-\\uDCB2\\uDCC0-\\uDCF2]|\\uD804[\\uDC03-\\uDC37\\uDC83-\\uDCAF\\uDCD0-\\uDCE8\\uDD03-\\uDD26\\uDD50-\\uDD72\\uDD76\\uDD83-\\uDDB2\\uDDC1-\\uDDC4\\uDDDA\\uDDDC\\uDE00-\\uDE11\\uDE13-\\uDE2B\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEDE\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3D\\uDF50\\uDF5D-\\uDF61]|\\uD805[\\uDC00-\\uDC34\\uDC47-\\uDC4A\\uDC80-\\uDCAF\\uDCC4\\uDCC5\\uDCC7\\uDD80-\\uDDAE\\uDDD8-\\uDDDB\\uDE00-\\uDE2F\\uDE44\\uDE80-\\uDEAA\\uDF00-\\uDF19]|\\uD806[\\uDCA0-\\uDCDF\\uDCFF\\uDEC0-\\uDEF8]|\\uD807[\\uDC00-\\uDC08\\uDC0A-\\uDC2E\\uDC40\\uDC72-\\uDC8F]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC00-\\uDC6E\\uDC80-\\uDD43]|[\\uD80C\\uD81C-\\uD820\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDED0-\\uDEED\\uDF00-\\uDF2F\\uDF40-\\uDF43\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDF00-\\uDF44\\uDF50\\uDF93-\\uDF9F\\uDFE0]|\\uD821[\\uDC00-\\uDFEC]|\\uD822[\\uDC00-\\uDEF2]|\\uD82C[\\uDC00\\uDC01]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99]|\\uD835[\\uDC00-\\uDC54\\uDC56-\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDEA5\\uDEA8-\\uDEC0\\uDEC2-\\uDEDA\\uDEDC-\\uDEFA\\uDEFC-\\uDF14\\uDF16-\\uDF34\\uDF36-\\uDF4E\\uDF50-\\uDF6E\\uDF70-\\uDF88\\uDF8A-\\uDFA8\\uDFAA-\\uDFC2\\uDFC4-\\uDFCB]|\\uD83A[\\uDC00-\\uDCC4\\uDD00-\\uDD43]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDED6\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF34\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1]|\\uD87E[\\uDC00-\\uDE1D]/,\n        // ECMAScript 6/Unicode v9.0.0 NonAsciiIdentifierPart:\n        NonAsciiIdentifierPart: /[\\xAA\\xB5\\xB7\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0300-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u0483-\\u0487\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0610-\\u061A\\u0620-\\u0669\\u066E-\\u06D3\\u06D5-\\u06DC\\u06DF-\\u06E8\\u06EA-\\u06FC\\u06FF\\u0710-\\u074A\\u074D-\\u07B1\\u07C0-\\u07F5\\u07FA\\u0800-\\u082D\\u0840-\\u085B\\u08A0-\\u08B4\\u08B6-\\u08BD\\u08D4-\\u08E1\\u08E3-\\u0963\\u0966-\\u096F\\u0971-\\u0983\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BC-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CE\\u09D7\\u09DC\\u09DD\\u09DF-\\u09E3\\u09E6-\\u09F1\\u0A01-\\u0A03\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A59-\\u0A5C\\u0A5E\\u0A66-\\u0A75\\u0A81-\\u0A83\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABC-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AD0\\u0AE0-\\u0AE3\\u0AE6-\\u0AEF\\u0AF9\\u0B01-\\u0B03\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3C-\\u0B44\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B5C\\u0B5D\\u0B5F-\\u0B63\\u0B66-\\u0B6F\\u0B71\\u0B82\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD0\\u0BD7\\u0BE6-\\u0BEF\\u0C00-\\u0C03\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C58-\\u0C5A\\u0C60-\\u0C63\\u0C66-\\u0C6F\\u0C80-\\u0C83\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBC-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CDE\\u0CE0-\\u0CE3\\u0CE6-\\u0CEF\\u0CF1\\u0CF2\\u0D01-\\u0D03\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D-\\u0D44\\u0D46-\\u0D48\\u0D4A-\\u0D4E\\u0D54-\\u0D57\\u0D5F-\\u0D63\\u0D66-\\u0D6F\\u0D7A-\\u0D7F\\u0D82\\u0D83\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDF\\u0DE6-\\u0DEF\\u0DF2\\u0DF3\\u0E01-\\u0E3A\\u0E40-\\u0E4E\\u0E50-\\u0E59\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB9\\u0EBB-\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EC8-\\u0ECD\\u0ED0-\\u0ED9\\u0EDC-\\u0EDF\\u0F00\\u0F18\\u0F19\\u0F20-\\u0F29\\u0F35\\u0F37\\u0F39\\u0F3E-\\u0F47\\u0F49-\\u0F6C\\u0F71-\\u0F84\\u0F86-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u1000-\\u1049\\u1050-\\u109D\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u135D-\\u135F\\u1369-\\u1371\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1714\\u1720-\\u1734\\u1740-\\u1753\\u1760-\\u176C\\u176E-\\u1770\\u1772\\u1773\\u1780-\\u17D3\\u17D7\\u17DC\\u17DD\\u17E0-\\u17E9\\u180B-\\u180D\\u1810-\\u1819\\u1820-\\u1877\\u1880-\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1920-\\u192B\\u1930-\\u193B\\u1946-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u19D0-\\u19DA\\u1A00-\\u1A1B\\u1A20-\\u1A5E\\u1A60-\\u1A7C\\u1A7F-\\u1A89\\u1A90-\\u1A99\\u1AA7\\u1AB0-\\u1ABD\\u1B00-\\u1B4B\\u1B50-\\u1B59\\u1B6B-\\u1B73\\u1B80-\\u1BF3\\u1C00-\\u1C37\\u1C40-\\u1C49\\u1C4D-\\u1C7D\\u1C80-\\u1C88\\u1CD0-\\u1CD2\\u1CD4-\\u1CF6\\u1CF8\\u1CF9\\u1D00-\\u1DF5\\u1DFB-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u200C\\u200D\\u203F\\u2040\\u2054\\u2071\\u207F\\u2090-\\u209C\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2118-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D7F-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2DE0-\\u2DFF\\u3005-\\u3007\\u3021-\\u302F\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u3099-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FD5\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA62B\\uA640-\\uA66F\\uA674-\\uA67D\\uA67F-\\uA6F1\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7AE\\uA7B0-\\uA7B7\\uA7F7-\\uA827\\uA840-\\uA873\\uA880-\\uA8C5\\uA8D0-\\uA8D9\\uA8E0-\\uA8F7\\uA8FB\\uA8FD\\uA900-\\uA92D\\uA930-\\uA953\\uA960-\\uA97C\\uA980-\\uA9C0\\uA9CF-\\uA9D9\\uA9E0-\\uA9FE\\uAA00-\\uAA36\\uAA40-\\uAA4D\\uAA50-\\uAA59\\uAA60-\\uAA76\\uAA7A-\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEF\\uAAF2-\\uAAF6\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB65\\uAB70-\\uABEA\\uABEC\\uABED\\uABF0-\\uABF9\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE00-\\uFE0F\\uFE20-\\uFE2F\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF10-\\uFF19\\uFF21-\\uFF3A\\uFF3F\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]|\\uD800[\\uDC00-\\uDC0B\\uDC0D-\\uDC26\\uDC28-\\uDC3A\\uDC3C\\uDC3D\\uDC3F-\\uDC4D\\uDC50-\\uDC5D\\uDC80-\\uDCFA\\uDD40-\\uDD74\\uDDFD\\uDE80-\\uDE9C\\uDEA0-\\uDED0\\uDEE0\\uDF00-\\uDF1F\\uDF30-\\uDF4A\\uDF50-\\uDF7A\\uDF80-\\uDF9D\\uDFA0-\\uDFC3\\uDFC8-\\uDFCF\\uDFD1-\\uDFD5]|\\uD801[\\uDC00-\\uDC9D\\uDCA0-\\uDCA9\\uDCB0-\\uDCD3\\uDCD8-\\uDCFB\\uDD00-\\uDD27\\uDD30-\\uDD63\\uDE00-\\uDF36\\uDF40-\\uDF55\\uDF60-\\uDF67]|\\uD802[\\uDC00-\\uDC05\\uDC08\\uDC0A-\\uDC35\\uDC37\\uDC38\\uDC3C\\uDC3F-\\uDC55\\uDC60-\\uDC76\\uDC80-\\uDC9E\\uDCE0-\\uDCF2\\uDCF4\\uDCF5\\uDD00-\\uDD15\\uDD20-\\uDD39\\uDD80-\\uDDB7\\uDDBE\\uDDBF\\uDE00-\\uDE03\\uDE05\\uDE06\\uDE0C-\\uDE13\\uDE15-\\uDE17\\uDE19-\\uDE33\\uDE38-\\uDE3A\\uDE3F\\uDE60-\\uDE7C\\uDE80-\\uDE9C\\uDEC0-\\uDEC7\\uDEC9-\\uDEE6\\uDF00-\\uDF35\\uDF40-\\uDF55\\uDF60-\\uDF72\\uDF80-\\uDF91]|\\uD803[\\uDC00-\\uDC48\\uDC80-\\uDCB2\\uDCC0-\\uDCF2]|\\uD804[\\uDC00-\\uDC46\\uDC66-\\uDC6F\\uDC7F-\\uDCBA\\uDCD0-\\uDCE8\\uDCF0-\\uDCF9\\uDD00-\\uDD34\\uDD36-\\uDD3F\\uDD50-\\uDD73\\uDD76\\uDD80-\\uDDC4\\uDDCA-\\uDDCC\\uDDD0-\\uDDDA\\uDDDC\\uDE00-\\uDE11\\uDE13-\\uDE37\\uDE3E\\uDE80-\\uDE86\\uDE88\\uDE8A-\\uDE8D\\uDE8F-\\uDE9D\\uDE9F-\\uDEA8\\uDEB0-\\uDEEA\\uDEF0-\\uDEF9\\uDF00-\\uDF03\\uDF05-\\uDF0C\\uDF0F\\uDF10\\uDF13-\\uDF28\\uDF2A-\\uDF30\\uDF32\\uDF33\\uDF35-\\uDF39\\uDF3C-\\uDF44\\uDF47\\uDF48\\uDF4B-\\uDF4D\\uDF50\\uDF57\\uDF5D-\\uDF63\\uDF66-\\uDF6C\\uDF70-\\uDF74]|\\uD805[\\uDC00-\\uDC4A\\uDC50-\\uDC59\\uDC80-\\uDCC5\\uDCC7\\uDCD0-\\uDCD9\\uDD80-\\uDDB5\\uDDB8-\\uDDC0\\uDDD8-\\uDDDD\\uDE00-\\uDE40\\uDE44\\uDE50-\\uDE59\\uDE80-\\uDEB7\\uDEC0-\\uDEC9\\uDF00-\\uDF19\\uDF1D-\\uDF2B\\uDF30-\\uDF39]|\\uD806[\\uDCA0-\\uDCE9\\uDCFF\\uDEC0-\\uDEF8]|\\uD807[\\uDC00-\\uDC08\\uDC0A-\\uDC36\\uDC38-\\uDC40\\uDC50-\\uDC59\\uDC72-\\uDC8F\\uDC92-\\uDCA7\\uDCA9-\\uDCB6]|\\uD808[\\uDC00-\\uDF99]|\\uD809[\\uDC00-\\uDC6E\\uDC80-\\uDD43]|[\\uD80C\\uD81C-\\uD820\\uD840-\\uD868\\uD86A-\\uD86C\\uD86F-\\uD872][\\uDC00-\\uDFFF]|\\uD80D[\\uDC00-\\uDC2E]|\\uD811[\\uDC00-\\uDE46]|\\uD81A[\\uDC00-\\uDE38\\uDE40-\\uDE5E\\uDE60-\\uDE69\\uDED0-\\uDEED\\uDEF0-\\uDEF4\\uDF00-\\uDF36\\uDF40-\\uDF43\\uDF50-\\uDF59\\uDF63-\\uDF77\\uDF7D-\\uDF8F]|\\uD81B[\\uDF00-\\uDF44\\uDF50-\\uDF7E\\uDF8F-\\uDF9F\\uDFE0]|\\uD821[\\uDC00-\\uDFEC]|\\uD822[\\uDC00-\\uDEF2]|\\uD82C[\\uDC00\\uDC01]|\\uD82F[\\uDC00-\\uDC6A\\uDC70-\\uDC7C\\uDC80-\\uDC88\\uDC90-\\uDC99\\uDC9D\\uDC9E]|\\uD834[\\uDD65-\\uDD69\\uDD6D-\\uDD72\\uDD7B-\\uDD82\\uDD85-\\uDD8B\\uDDAA-\\uDDAD\\uDE42-\\uDE44]|\\uD835[\\uDC00-\\uDC54\\uDC56-\\uDC9C\\uDC9E\\uDC9F\\uDCA2\\uDCA5\\uDCA6\\uDCA9-\\uDCAC\\uDCAE-\\uDCB9\\uDCBB\\uDCBD-\\uDCC3\\uDCC5-\\uDD05\\uDD07-\\uDD0A\\uDD0D-\\uDD14\\uDD16-\\uDD1C\\uDD1E-\\uDD39\\uDD3B-\\uDD3E\\uDD40-\\uDD44\\uDD46\\uDD4A-\\uDD50\\uDD52-\\uDEA5\\uDEA8-\\uDEC0\\uDEC2-\\uDEDA\\uDEDC-\\uDEFA\\uDEFC-\\uDF14\\uDF16-\\uDF34\\uDF36-\\uDF4E\\uDF50-\\uDF6E\\uDF70-\\uDF88\\uDF8A-\\uDFA8\\uDFAA-\\uDFC2\\uDFC4-\\uDFCB\\uDFCE-\\uDFFF]|\\uD836[\\uDE00-\\uDE36\\uDE3B-\\uDE6C\\uDE75\\uDE84\\uDE9B-\\uDE9F\\uDEA1-\\uDEAF]|\\uD838[\\uDC00-\\uDC06\\uDC08-\\uDC18\\uDC1B-\\uDC21\\uDC23\\uDC24\\uDC26-\\uDC2A]|\\uD83A[\\uDC00-\\uDCC4\\uDCD0-\\uDCD6\\uDD00-\\uDD4A\\uDD50-\\uDD59]|\\uD83B[\\uDE00-\\uDE03\\uDE05-\\uDE1F\\uDE21\\uDE22\\uDE24\\uDE27\\uDE29-\\uDE32\\uDE34-\\uDE37\\uDE39\\uDE3B\\uDE42\\uDE47\\uDE49\\uDE4B\\uDE4D-\\uDE4F\\uDE51\\uDE52\\uDE54\\uDE57\\uDE59\\uDE5B\\uDE5D\\uDE5F\\uDE61\\uDE62\\uDE64\\uDE67-\\uDE6A\\uDE6C-\\uDE72\\uDE74-\\uDE77\\uDE79-\\uDE7C\\uDE7E\\uDE80-\\uDE89\\uDE8B-\\uDE9B\\uDEA1-\\uDEA3\\uDEA5-\\uDEA9\\uDEAB-\\uDEBB]|\\uD869[\\uDC00-\\uDED6\\uDF00-\\uDFFF]|\\uD86D[\\uDC00-\\uDF34\\uDF40-\\uDFFF]|\\uD86E[\\uDC00-\\uDC1D\\uDC20-\\uDFFF]|\\uD873[\\uDC00-\\uDEA1]|\\uD87E[\\uDC00-\\uDE1D]|\\uDB40[\\uDD00-\\uDDEF]/\n    };\n\n    function isDecimalDigit(ch) {\n        return 0x30 <= ch && ch <= 0x39;  // 0..9\n    }\n\n    function isHexDigit(ch) {\n        return 0x30 <= ch && ch <= 0x39 ||  // 0..9\n            0x61 <= ch && ch <= 0x66 ||     // a..f\n            0x41 <= ch && ch <= 0x46;       // A..F\n    }\n\n    function isOctalDigit(ch) {\n        return ch >= 0x30 && ch <= 0x37;  // 0..7\n    }\n\n    // 7.2 White Space\n\n    NON_ASCII_WHITESPACES = [\n        0x1680,\n        0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A,\n        0x202F, 0x205F,\n        0x3000,\n        0xFEFF\n    ];\n\n    function isWhiteSpace(ch) {\n        return ch === 0x20 || ch === 0x09 || ch === 0x0B || ch === 0x0C || ch === 0xA0 ||\n            ch >= 0x1680 && NON_ASCII_WHITESPACES.indexOf(ch) >= 0;\n    }\n\n    // 7.3 Line Terminators\n\n    function isLineTerminator(ch) {\n        return ch === 0x0A || ch === 0x0D || ch === 0x2028 || ch === 0x2029;\n    }\n\n    // 7.6 Identifier Names and Identifiers\n\n    function fromCodePoint(cp) {\n        if (cp <= 0xFFFF) { return String.fromCharCode(cp); }\n        var cu1 = String.fromCharCode(Math.floor((cp - 0x10000) / 0x400) + 0xD800);\n        var cu2 = String.fromCharCode(((cp - 0x10000) % 0x400) + 0xDC00);\n        return cu1 + cu2;\n    }\n\n    IDENTIFIER_START = new Array(0x80);\n    for(ch = 0; ch < 0x80; ++ch) {\n        IDENTIFIER_START[ch] =\n            ch >= 0x61 && ch <= 0x7A ||  // a..z\n            ch >= 0x41 && ch <= 0x5A ||  // A..Z\n            ch === 0x24 || ch === 0x5F;  // $ (dollar) and _ (underscore)\n    }\n\n    IDENTIFIER_PART = new Array(0x80);\n    for(ch = 0; ch < 0x80; ++ch) {\n        IDENTIFIER_PART[ch] =\n            ch >= 0x61 && ch <= 0x7A ||  // a..z\n            ch >= 0x41 && ch <= 0x5A ||  // A..Z\n            ch >= 0x30 && ch <= 0x39 ||  // 0..9\n            ch === 0x24 || ch === 0x5F;  // $ (dollar) and _ (underscore)\n    }\n\n    function isIdentifierStartES5(ch) {\n        return ch < 0x80 ? IDENTIFIER_START[ch] : ES5Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch));\n    }\n\n    function isIdentifierPartES5(ch) {\n        return ch < 0x80 ? IDENTIFIER_PART[ch] : ES5Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch));\n    }\n\n    function isIdentifierStartES6(ch) {\n        return ch < 0x80 ? IDENTIFIER_START[ch] : ES6Regex.NonAsciiIdentifierStart.test(fromCodePoint(ch));\n    }\n\n    function isIdentifierPartES6(ch) {\n        return ch < 0x80 ? IDENTIFIER_PART[ch] : ES6Regex.NonAsciiIdentifierPart.test(fromCodePoint(ch));\n    }\n\n    module.exports = {\n        isDecimalDigit: isDecimalDigit,\n        isHexDigit: isHexDigit,\n        isOctalDigit: isOctalDigit,\n        isWhiteSpace: isWhiteSpace,\n        isLineTerminator: isLineTerminator,\n        isIdentifierStartES5: isIdentifierStartES5,\n        isIdentifierPartES5: isIdentifierPartES5,\n        isIdentifierStartES6: isIdentifierStartES6,\n        isIdentifierPartES6: isIdentifierPartES6\n    };\n}());\n/* vim: set sw=4 ts=4 et tw=80 : */\n","\"use strict\";\n\nconst REPLACED = Symbol(\"replaced\");\n\nconst h = require(\"./helpers\");\n\nmodule.exports = t => {\n  function mergeNestedIfs(path) {\n    const consequent = path.get(\"consequent\");\n    const alternate = path.get(\"alternate\"); // not nested if\n\n    if (!consequent.isIfStatement()) return; // there are no alternate nodes in both the if statements (nested)\n\n    if (alternate.node || consequent.get(\"alternate\").node) return;\n    const test = path.get(\"test\");\n    test.replaceWith(t.logicalExpression(\"&&\", test.node, consequent.get(\"test\").node));\n    consequent.replaceWith(t.clone(consequent.get(\"consequent\").node));\n  } // No alternate, make into a guarded expression\n\n\n  function toGuardedExpression(path) {\n    const node = path.node;\n\n    if (node.consequent && !node.alternate && node.consequent.type === \"ExpressionStatement\") {\n      let op = \"&&\";\n\n      if (t.isUnaryExpression(node.test, {\n        operator: \"!\"\n      })) {\n        node.test = node.test.argument;\n        op = \"||\";\n      }\n\n      path.replaceWith(t.expressionStatement(t.logicalExpression(op, node.test, node.consequent.expression)));\n      return REPLACED;\n    }\n  } // both consequent and alternate are expressions, turn into ternary\n\n\n  function toTernary(path) {\n    const node = path.node;\n\n    if (t.isExpressionStatement(node.consequent) && t.isExpressionStatement(node.alternate)) {\n      path.replaceWith(t.conditionalExpression(node.test, node.consequent.expression, node.alternate.expression));\n      return REPLACED;\n    }\n  } // consequent and alternate are return -- conditional.\n\n\n  function toConditional(path) {\n    const node = path.node;\n\n    if (t.isReturnStatement(node.consequent) && t.isReturnStatement(node.alternate)) {\n      if (!node.consequent.argument && !node.alternate.argument) {\n        path.replaceWith(t.expressionStatement(node.test));\n        return REPLACED;\n      }\n\n      path.replaceWith(t.returnStatement(t.conditionalExpression(node.test, node.consequent.argument || h.VOID_0(t), node.alternate.argument || h.VOID_0(t))));\n      return REPLACED;\n    }\n  } // There is nothing after this If block. And one or both\n  // of the consequent and alternate are either expression statment\n  // or return statements.\n\n\n  function toReturn(path) {\n    const node = path.node;\n\n    if (!path.getSibling(path.key + 1).node && path.parentPath && path.parentPath.parentPath && path.parentPath.parentPath.isFunction()) {\n      // Only the consequent is a return, void the alternate.\n      if (t.isReturnStatement(node.consequent) && t.isExpressionStatement(node.alternate)) {\n        if (!node.consequent.argument) {\n          path.replaceWith(t.expressionStatement(t.logicalExpression(\"||\", node.test, node.alternate.expression)));\n          return REPLACED;\n        }\n\n        path.replaceWith(t.returnStatement(t.conditionalExpression(node.test, node.consequent.argument || h.VOID_0(t), t.unaryExpression(\"void\", node.alternate.expression, true))));\n        return REPLACED;\n      } // Only the alternate is a return, void the consequent.\n\n\n      if (t.isReturnStatement(node.alternate) && t.isExpressionStatement(node.consequent)) {\n        if (!node.alternate.argument) {\n          path.replaceWith(t.expressionStatement(t.logicalExpression(\"&&\", node.test, node.consequent.expression)));\n          return REPLACED;\n        }\n\n        path.replaceWith(t.returnStatement(t.conditionalExpression(node.test, t.unaryExpression(\"void\", node.consequent.expression, true), node.alternate.argument || h.VOID_0(t))));\n        return REPLACED;\n      }\n\n      if (t.isReturnStatement(node.consequent) && !node.alternate) {\n        if (!node.consequent.argument) {\n          path.replaceWith(t.expressionStatement(node.test));\n          return REPLACED;\n        } // This would only be worth it if the previous statement was an if\n        // because then we may merge to create a conditional.\n\n\n        if (path.getSibling(path.key - 1).isIfStatement()) {\n          path.replaceWith(t.returnStatement(t.conditionalExpression(node.test, node.consequent.argument || h.VOID_0(t), h.VOID_0(t))));\n          return REPLACED;\n        }\n      }\n\n      if (t.isReturnStatement(node.alternate) && !node.consequent) {\n        if (!node.alternate.argument) {\n          path.replaceWith(t.expressionStatement(node.test));\n          return REPLACED;\n        } // Same as above.\n\n\n        if (path.getSibling(path.key - 1).isIfStatement()) {\n          path.replaceWith(t.returnStatement(t.conditionalExpression(node.test, node.alternate.argument || h.VOID_0(t), h.VOID_0(t))));\n          return REPLACED;\n        }\n      }\n    }\n\n    let next = path.getSibling(path.key + 1); // If the next satatement(s) is an if statement and we can simplify that\n    // to potentailly be an expression (or a return) then this will make it\n    // easier merge.\n\n    if (next.isIfStatement()) {\n      next.pushContext(path.context);\n      next.visit();\n      next.popContext();\n      next = path.getSibling(path.key + 1);\n    } // Some other visitor might have deleted our node. OUR NODE ;_;\n\n\n    if (!path.node) {\n      return;\n    } // No alternate but the next statement is a return\n    // also turn into a return conditional\n\n\n    if (t.isReturnStatement(node.consequent) && !node.alternate && next.isReturnStatement()) {\n      const nextArg = next.node.argument || h.VOID_0(t);\n      next.remove();\n      path.replaceWith(t.returnStatement(t.conditionalExpression(node.test, node.consequent.argument || h.VOID_0(t), nextArg)));\n      return REPLACED;\n    } // Next is the last expression, turn into a return while void'ing the exprs\n\n\n    if (path.parentPath && path.parentPath.parentPath && path.parentPath.parentPath.isFunction() && !path.getSibling(path.key + 2).node && t.isReturnStatement(node.consequent) && !node.alternate && next.isExpressionStatement()) {\n      const nextExpr = next.node.expression;\n      next.remove();\n\n      if (node.consequent.argument) {\n        path.replaceWith(t.returnStatement(t.conditionalExpression(node.test, node.consequent.argument, t.unaryExpression(\"void\", nextExpr, true))));\n        return REPLACED;\n      }\n\n      path.replaceWith(t.logicalExpression(\"||\", node.test, nextExpr));\n      return REPLACED;\n    }\n  } // Remove else for if-return\n\n\n  function removeUnnecessaryElse(path) {\n    const node = path.node;\n    const consequent = path.get(\"consequent\");\n    const alternate = path.get(\"alternate\");\n\n    if (consequent.node && alternate.node && (consequent.isReturnStatement() || consequent.isBlockStatement() && t.isReturnStatement(consequent.node.body[consequent.node.body.length - 1])) && ( // don't hoist declarations\n    // TODO: validate declarations after fixing scope issues\n    alternate.isBlockStatement() ? !alternate.get(\"body\").some(stmt => stmt.isVariableDeclaration({\n      kind: \"let\"\n    }) || stmt.isVariableDeclaration({\n      kind: \"const\"\n    })) : true)) {\n      path.insertAfter(alternate.isBlockStatement() ? alternate.node.body.map(el => t.clone(el)) : t.clone(alternate.node));\n      node.alternate = null;\n      return REPLACED;\n    }\n  }\n\n  function runTransforms(path) {\n    // ordered\n    const transforms = [toGuardedExpression, toTernary, toConditional, toReturn, removeUnnecessaryElse]; // run each of the replacement till we replace something\n    // which is identified by the Symbol(REPLACED) that each of the\n    // functions return when they replace something\n\n    for (var _i = 0; _i < transforms.length; _i++) {\n      const transform = transforms[_i];\n\n      if (transform(path) === REPLACED) {\n        break;\n      }\n    }\n  } // If the consequent is if and the altenrate is not then\n  // switch them out. That way we know we don't have to print\n  // a block.x\n\n\n  function switchConsequent(path) {\n    const node = path.node;\n\n    if (!node.alternate) {\n      return;\n    }\n\n    if (!t.isIfStatement(node.consequent)) {\n      return;\n    }\n\n    if (t.isIfStatement(node.alternate)) {\n      return;\n    }\n\n    node.test = t.unaryExpression(\"!\", node.test, true);\n    var _ref = [node.consequent, node.alternate];\n    node.alternate = _ref[0];\n    node.consequent = _ref[1];\n  } // Make if statements with conditional returns in the body into\n  // an if statement that guards the rest of the block.\n\n\n  function conditionalReturnToGuards(path) {\n    const node = path.node;\n\n    if (!path.inList || !path.get(\"consequent\").isBlockStatement() || node.alternate) {\n      return;\n    }\n\n    let ret;\n    let test;\n    const exprs = [];\n    const statements = node.consequent.body;\n\n    for (let i = 0, statement; statement = statements[i]; i++) {\n      if (t.isExpressionStatement(statement)) {\n        exprs.push(statement.expression);\n      } else if (t.isIfStatement(statement)) {\n        if (i < statements.length - 1) {\n          // This isn't the last statement. Bail.\n          return;\n        }\n\n        if (statement.alternate) {\n          return;\n        }\n\n        if (!t.isReturnStatement(statement.consequent)) {\n          return;\n        }\n\n        ret = statement.consequent;\n        test = statement.test;\n      } else {\n        return;\n      }\n    }\n\n    if (!test || !ret) {\n      return;\n    }\n\n    exprs.push(test);\n    const expr = exprs.length === 1 ? exprs[0] : t.sequenceExpression(exprs);\n    const replacement = t.logicalExpression(\"&&\", node.test, expr);\n    path.replaceWith(t.ifStatement(replacement, ret, null));\n  }\n\n  return {\n    mergeNestedIfs,\n    simplify: runTransforms,\n    switchConsequent,\n    conditionalReturnToGuards\n  };\n};","var arraySome = require('./_arraySome'),\n    baseIteratee = require('./_baseIteratee'),\n    baseSome = require('./_baseSome'),\n    isArray = require('./isArray'),\n    isIterateeCall = require('./_isIterateeCall');\n\n/**\n * Checks if `predicate` returns truthy for **any** element of `collection`.\n * Iteration is stopped once `predicate` returns truthy. The predicate is\n * invoked with three arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n * @example\n *\n * _.some([null, 0, 'yes', false], Boolean);\n * // => true\n *\n * var users = [\n *   { 'user': 'barney', 'active': true },\n *   { 'user': 'fred',   'active': false }\n * ];\n *\n * // The `_.matches` iteratee shorthand.\n * _.some(users, { 'user': 'barney', 'active': false });\n * // => false\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.some(users, ['active', false]);\n * // => true\n *\n * // The `_.property` iteratee shorthand.\n * _.some(users, 'active');\n * // => true\n */\nfunction some(collection, predicate, guard) {\n  var func = isArray(collection) ? arraySome : baseSome;\n  if (guard && isIterateeCall(collection, predicate, guard)) {\n    predicate = undefined;\n  }\n  return func(collection, baseIteratee(predicate, 3));\n}\n\nmodule.exports = some;\n","\"use strict\";\n\nmodule.exports = function ({\n  types: t\n}) {\n  function liftDeclaration(path, body, kind) {\n    if (body[0] && body[0].isVariableDeclaration({\n      kind: kind\n    })) {\n      if (body[0].node.declarations.length > 1) {\n        return;\n      }\n\n      if (body[1] && body[1].isVariableDeclaration({\n        kind: kind\n      })) {\n        return;\n      }\n\n      const firstNode = body[0].node.declarations[0];\n\n      if (!t.isIdentifier(firstNode.id) || !firstNode.init) {\n        return;\n      }\n\n      const init = path.get(\"init\");\n\n      if (!init.isVariableDeclaration({\n        kind: kind\n      })) {\n        return;\n      }\n\n      init.pushContainer(\"declarations\", t.variableDeclarator(firstNode.id));\n      body[0].replaceWith(t.assignmentExpression(\"=\", t.clone(firstNode.id), t.clone(firstNode.init)));\n    }\n  }\n\n  return {\n    name: \"transform-merge-sibling-variables\",\n    visitor: {\n      ForStatement(path) {\n        // Lift declarations to the loop initializer\n        let body = path.get(\"body\");\n        body = body.isBlockStatement() ? body.get(\"body\") : [body];\n        liftDeclaration(path, body, \"var\");\n        liftDeclaration(path, body, \"let\");\n      },\n\n      VariableDeclaration: {\n        enter: [// concat variables of the same kind with their siblings\n        function (path) {\n          if (!path.inList) {\n            return;\n          }\n\n          const node = path.node;\n          let sibling = path.getSibling(path.key + 1);\n          let declarations = [];\n\n          while (sibling.isVariableDeclaration({\n            kind: node.kind\n          })) {\n            declarations = declarations.concat(sibling.node.declarations);\n            sibling.remove();\n            sibling = path.getSibling(path.key + 1);\n          }\n\n          if (declarations.length > 0) {\n            path.replaceWith(t.variableDeclaration(node.kind, [...node.declarations, ...declarations]));\n          }\n        }, // concat `var` declarations next to for loops with it's initialisers.\n        // block-scoped `let` and `const` are not moved because the for loop\n        // is a different block scope.\n        function (path) {\n          if (!path.inList) {\n            return;\n          }\n\n          const node = path.node;\n\n          if (node.kind !== \"var\") {\n            return;\n          }\n\n          const next = path.getSibling(path.key + 1);\n\n          if (!next.isForStatement()) {\n            return;\n          }\n\n          const init = next.get(\"init\");\n\n          if (!init.isVariableDeclaration({\n            kind: node.kind\n          })) {\n            return;\n          }\n\n          const declarations = node.declarations.concat(init.node.declarations); // temporary workaround to forces babel recalculate scope,\n          // references and binding until babel/babel#4818 resolved\n\n          path.remove();\n          init.replaceWith(t.variableDeclaration(\"var\", declarations));\n        }]\n      }\n    }\n  };\n};","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); }\n\nfunction _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nconst COLLAPSERS = [require(\"./object-collapser\"), require(\"./array-collapser\"), require(\"./array-property-collapser\"), require(\"./set-collapser\")].map(Collapser => {\n  return new Collapser();\n});\n\nfunction getFunctionParent(path, scopeParent) {\n  const parent = path.findParent(p => p.isFunction()); // don\"t traverse higher than the function the var is defined in.\n\n  return parent === scopeParent ? null : parent;\n}\n\nfunction getFunctionReferences(path, scopeParent, references = new Set()) {\n  for (let func = getFunctionParent(path, scopeParent); func; func = getFunctionParent(func, scopeParent)) {\n    const id = func.node.id;\n    const binding = id && func.scope.getBinding(id.name);\n\n    if (!binding) {\n      continue;\n    }\n\n    binding.referencePaths.forEach(path => {\n      if (!references.has(path)) {\n        references.add(path);\n        getFunctionReferences(path, scopeParent, references);\n      }\n    });\n  }\n\n  return references;\n}\n\nfunction getIdAndFunctionReferences(name, parent) {\n  // Returns false if there's an error. Otherwise returns a list of references.\n  const binding = parent.scope.getBinding(name);\n\n  if (!binding) {\n    return false;\n  }\n\n  const references = binding.referencePaths.reduce((references, ref) => {\n    references.add(ref);\n    getFunctionReferences(ref, parent, references);\n    return references;\n  }, new Set());\n  return Array.from(references);\n}\n\nfunction validateTopLevel(path) {\n  // Ensures the structure is of the form (roughly):\n  // {\n  //   ...\n  //   var foo = expr;\n  //   ...\n  // }\n  // returns null if not of this form\n  // otherwise returns [foo as string, ?rval, index of the variable declaration]\n  const declarations = path.get(\"declarations\");\n\n  if (declarations.length !== 1) {\n    return;\n  }\n\n  const declaration = declarations[0];\n  const id = declaration.get(\"id\"),\n        init = declaration.get(\"init\");\n\n  if (!id.isIdentifier()) {\n    return;\n  }\n\n  const parent = path.parentPath;\n\n  if (!parent.isBlockParent() || !parent.isScopable()) {\n    return;\n  }\n\n  const body = parent.get(\"body\");\n\n  if (!Array.isArray(body)) {\n    return;\n  }\n\n  const startIndex = body.indexOf(path);\n\n  if (startIndex === -1) {\n    return;\n  }\n\n  return [id.node.name, init, startIndex];\n}\n\nfunction collectExpressions(path, isExprTypeValid) {\n  // input: ExprStatement => 'a | SequenceExpression\n  // SequenceExpression => 'a list\n  // Validates 'a is of the right type\n  // returns null if found inconsistency, else returns Array<\"a>\n  if (path.isExpressionStatement()) {\n    const exprs = collectExpressions(path.get(\"expression\"), isExprTypeValid);\n    return exprs !== null ? exprs : null;\n  }\n\n  if (path.isSequenceExpression()) {\n    const exprs = path.get(\"expressions\").map(p => collectExpressions(p, isExprTypeValid));\n\n    if (exprs.some(e => e === null)) {\n      return null;\n    } else {\n      return exprs.reduce((s, n) => s.concat(n), []); // === Array.flatten\n    }\n  }\n\n  if (isExprTypeValid(path)) {\n    return [path];\n  }\n\n  return null;\n}\n\nfunction getContiguousStatementsAndExpressions(body, start, end, isExprTypeValid, checkExpr) {\n  const statements = [];\n  let allExprs = [];\n\n  for (let i = start; i < end; i++) {\n    const exprs = collectExpressions(body[i], isExprTypeValid);\n\n    if (exprs === null || !exprs.every(e => checkExpr(e))) {\n      break;\n    }\n\n    statements.push(body[i]);\n    allExprs = allExprs.concat(exprs);\n  }\n\n  return [statements, allExprs];\n}\n\nfunction getReferenceChecker(references) {\n  // returns a function s.t. given an expr, returns true iff expr is an ancestor of a reference\n  return expr => references.some(r => r === expr || r.isDescendant(expr));\n}\n\nfunction tryUseCollapser(t, collapser, varDecl, topLevel, checkReference) {\n  // Returns true iff successfully used the collapser. Otherwise returns undefined.\n  const _topLevel = _slicedToArray(topLevel, 3),\n        name = _topLevel[0],\n        init = _topLevel[1],\n        startIndex = _topLevel[2];\n\n  if (!collapser.isInitTypeValid(init)) {\n    return;\n  }\n\n  const body = varDecl.parentPath.get(\"body\");\n\n  const _getContiguousStateme = getContiguousStatementsAndExpressions(body, startIndex + 1, body.length, collapser.isExpressionTypeValid, collapser.getExpressionChecker(name, checkReference)),\n        _getContiguousStateme2 = _slicedToArray(_getContiguousStateme, 2),\n        statements = _getContiguousStateme2[0],\n        exprs = _getContiguousStateme2[1];\n\n  if (statements.length === 0) {\n    return;\n  }\n\n  const assignments = exprs.map(e => collapser.extractAssignment(e));\n  const oldInit = init.node;\n  const newInit = t.cloneDeep(oldInit);\n\n  if (!assignments.every(assignment => collapser.addSuccessfully(t, assignment, newInit))) {\n    return;\n  } // some collapses may increase the size\n\n\n  if (!collapser.isSizeSmaller({\n    newInit,\n    oldInit,\n    varDecl,\n    assignments,\n    statements\n  })) {\n    return;\n  }\n\n  init.replaceWith(newInit);\n  statements.forEach(s => s.remove());\n  return true;\n}\n\nmodule.exports = function ({\n  types: t\n}) {\n  return {\n    name: \"transform-inline-consecutive-adds\",\n    visitor: {\n      VariableDeclaration(varDecl) {\n        const topLevel = validateTopLevel(varDecl);\n\n        if (!topLevel) {\n          return;\n        }\n\n        const _topLevel2 = _slicedToArray(topLevel, 1),\n              name = _topLevel2[0];\n\n        const references = getIdAndFunctionReferences(name, varDecl.parentPath);\n\n        if (references === false) {\n          return;\n        }\n\n        const checkReference = getReferenceChecker(references);\n\n        if (COLLAPSERS.some(c => tryUseCollapser(t, c, varDecl, topLevel, checkReference))) {\n          return;\n        }\n      }\n\n    }\n  };\n};","\"use strict\";\n\nconst flipSeen = Symbol(\"flipSeen\");\n\nmodule.exports = function (t) {\n  return {\n    hasSeen(node) {\n      return !!node[flipSeen];\n    },\n\n    // Takes an expressions and determines if it has\n    // more nodes that could benifit from flipping than not.\n    shouldFlip(topNode, savings = 0) {\n      visit(topNode);\n      return savings > 0;\n\n      function visit(node) {\n        if (t.isUnaryExpression(node, {\n          operator: \"!\"\n        })) {\n          savings++;\n          return;\n        }\n\n        if (t.isLogicalExpression(node)) {\n          visit(node.left);\n          visit(node.right);\n          return;\n        }\n\n        if (!(t.isBinaryExpression(node) && t.EQUALITY_BINARY_OPERATORS.indexOf(node.operator) > -1)) {\n          // Binary expressions wouldn't hurut because we know how to flip them\n          savings--;\n        }\n      }\n    },\n\n    flip(node, resultNotUsed) {\n      let lastNodeDesc;\n      const ret = visit(node);\n      ret[flipSeen] = true;\n\n      if (resultNotUsed && lastNodeDesc) {\n        const _lastNodeDesc = lastNodeDesc,\n              parent = _lastNodeDesc.parent,\n              key = _lastNodeDesc.key;\n\n        if (parent && key && t.isUnaryExpression(parent[key], {\n          operator: \"!\"\n        })) {\n          parent[key] = parent[key].argument;\n        }\n      }\n\n      return ret;\n\n      function visit(node, parent, key) {\n        lastNodeDesc = {\n          parent,\n          key\n        };\n\n        if (t.isUnaryExpression(node, {\n          operator: \"!\"\n        })) {\n          return node.argument;\n        }\n\n        if (t.isLogicalExpression(node)) {\n          node.operator = node.operator === \"&&\" ? \"||\" : \"&&\";\n          node.left = visit(node.left, node, \"left\");\n          node.right = visit(node.right, node, \"right\");\n          return node;\n        }\n\n        if (t.isBinaryExpression(node)) {\n          let operator;\n\n          switch (node.operator) {\n            case \"!==\":\n              operator = \"===\";\n              break;\n\n            case \"===\":\n              operator = \"!==\";\n              break;\n\n            case \"!=\":\n              operator = \"==\";\n              break;\n\n            case \"==\":\n              operator = \"!=\";\n              break;\n          }\n\n          if (operator) {\n            node.operator = operator;\n            return node;\n          } // Falls through to unary expression\n\n        }\n\n        return t.unaryExpression(\"!\", node, true);\n      }\n    }\n\n  };\n};","var baseEach = require('./_baseEach');\n\n/**\n * The base implementation of `_.some` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction baseSome(collection, predicate) {\n  var result;\n\n  baseEach(collection, function(value, index, collection) {\n    result = predicate(value, index, collection);\n    return !result;\n  });\n  return !!result;\n}\n\nmodule.exports = baseSome;\n","var isStrictComparable = require('./_isStrictComparable'),\n    keys = require('./keys');\n\n/**\n * Gets the property names, values, and compare flags of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the match data of `object`.\n */\nfunction getMatchData(object) {\n  var result = keys(object),\n      length = result.length;\n\n  while (length--) {\n    var key = result[length],\n        value = object[key];\n\n    result[length] = [key, value, isStrictComparable(value)];\n  }\n  return result;\n}\n\nmodule.exports = getMatchData;\n","/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction arraySome(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (predicate(array[index], index, array)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nmodule.exports = arraySome;\n","\"use strict\";\n\nmodule.exports = function ({\n  types: t\n}) {\n  const VOID_0 = t.unaryExpression(\"void\", t.numericLiteral(0), true);\n  return {\n    name: \"transform-undefined-to-void\",\n    visitor: {\n      ReferencedIdentifier(path) {\n        if (path.node.name === \"undefined\") {\n          path.replaceWith(VOID_0);\n        }\n      }\n\n    }\n  };\n};","var baseForOwn = require('./_baseForOwn'),\n    createBaseEach = require('./_createBaseEach');\n\n/**\n * The base implementation of `_.forEach` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array|Object} Returns `collection`.\n */\nvar baseEach = createBaseEach(baseForOwn);\n\nmodule.exports = baseEach;\n","\"use strict\";\n\nmodule.exports = function (t) {\n  return function isVoid0(expr) {\n    return t.isUnaryExpression(expr, {\n      operator: \"void\"\n    }) && t.isNumericLiteral(expr.argument, {\n      value: 0\n    });\n  };\n};","\"use strict\";\n\nfunction _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); }\n\nfunction _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter); }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nconst LEAF_NODE = Symbol(\"LEAF_NODE\");\nmodule.exports = class PatternMatch {\n  constructor(patterns) {\n    this.decisionTree = this.makeDecisionTree(patterns);\n  }\n\n  handle(input, isMatch) {\n    const result = this.match(input, isMatch);\n\n    if (!result.match) {\n      throw new Error(\"No Match Found for \" + input.toString());\n    }\n\n    if (typeof result.value !== \"function\") {\n      throw new Error(\"Expecting a function. Instead got - \" + result.value.toString());\n    }\n\n    result.value.call(null, input, result.keys);\n  }\n\n  match(input, isMatch = (a, b) => a === b) {\n    let current = this.decisionTree;\n    const result = {\n      match: false,\n      value: void 0,\n      keys: []\n    }; // to handle falsy keys\n\n    const NO_MATCH = Symbol(\"NO_MATCH\");\n\n    for (let i = 0; i < input.length; i++) {\n      let matchedKey = NO_MATCH; // because map doesn't support custom key equal function\n\n      var _iteratorNormalCompletion = true;\n      var _didIteratorError = false;\n      var _iteratorError = undefined;\n\n      try {\n        for (var _iterator = current.keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n          const key = _step.value;\n\n          if (isMatch(key, input[i])) {\n            matchedKey = key;\n            result.keys.push(matchedKey);\n            break;\n          }\n        }\n      } catch (err) {\n        _didIteratorError = true;\n        _iteratorError = err;\n      } finally {\n        try {\n          if (!_iteratorNormalCompletion && _iterator.return != null) {\n            _iterator.return();\n          }\n        } finally {\n          if (_didIteratorError) {\n            throw _iteratorError;\n          }\n        }\n      }\n\n      if (matchedKey !== NO_MATCH) {\n        current = current.get(matchedKey);\n\n        if (i === input.length - 1) {\n          if (current.has(LEAF_NODE)) {\n            result.match = true;\n            result.value = current.get(LEAF_NODE);\n          }\n\n          break;\n        }\n      } else {\n        break;\n      }\n    }\n\n    return result;\n  }\n\n  makeDecisionTree(patterns) {\n    // order of keys in a Map is the order of insertion\n    const root = new Map();\n    var _iteratorNormalCompletion2 = true;\n    var _didIteratorError2 = false;\n    var _iteratorError2 = undefined;\n\n    try {\n      for (var _iterator2 = patterns[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n        const pattern = _step2.value;\n        make(root, pattern);\n      }\n    } catch (err) {\n      _didIteratorError2 = true;\n      _iteratorError2 = err;\n    } finally {\n      try {\n        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {\n          _iterator2.return();\n        }\n      } finally {\n        if (_didIteratorError2) {\n          throw _iteratorError2;\n        }\n      }\n    }\n\n    return root;\n\n    function make(parent, pattern) {\n      if (pattern.length < 2) {\n        throw new Error(\"at least 2 elements required in a pattern\");\n      }\n\n      if (pattern.length === 2) {\n        if (parent.has(pattern[0])) {\n          const pattern0 = parent.get(pattern[0]);\n\n          if (!pattern0.has(LEAF_NODE)) {\n            pattern0.set(LEAF_NODE, pattern[1]);\n          } // here we don't handle duplicates\n          // this pattern would have already been matched\n\n        } else {\n          parent.set(pattern[0], new Map([[LEAF_NODE, pattern[1]]]));\n        }\n\n        return parent;\n      }\n\n      const _pattern = _toArray(pattern),\n            current = _pattern[0],\n            rest = _pattern.slice(1);\n\n      if (parent.has(current)) {\n        make(parent.get(current), rest);\n      } else {\n        parent.set(current, make(new Map(), rest));\n      }\n\n      return parent;\n    }\n  }\n\n};","var baseGetTag = require('./_baseGetTag'),\n    getPrototype = require('./_getPrototype'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString.call(Ctor) == objectCtorString;\n}\n\nmodule.exports = isPlainObject;\n","var baseIsMatch = require('./_baseIsMatch'),\n    getMatchData = require('./_getMatchData'),\n    matchesStrictComparable = require('./_matchesStrictComparable');\n\n/**\n * The base implementation of `_.matches` which doesn't clone `source`.\n *\n * @private\n * @param {Object} source The object of property values to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction baseMatches(source) {\n  var matchData = getMatchData(source);\n  if (matchData.length == 1 && matchData[0][2]) {\n    return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n  }\n  return function(object) {\n    return object === source || baseIsMatch(object, source, matchData);\n  };\n}\n\nmodule.exports = baseMatches;\n","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); }\n\nfunction _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nmodule.exports = ({\n  types: t\n}) => {\n  const flipExpressions = require(\"babel-helper-flip-expressions\")(t);\n\n  const toMultipleSequenceExpressions = require(\"babel-helper-to-multiple-sequence-expressions\")(t);\n\n  const ifStatement = require(\"./if-statement\")(t);\n\n  const conditionalExpression = require(\"./conditional-expression\")(t);\n\n  const logicalExpression = require(\"./logical-expression\")(t);\n\n  const assignmentExpression = require(\"./assignment-expression\")(t);\n\n  const VOID_0 = t.unaryExpression(\"void\", t.numericLiteral(0), true);\n  const condExprSeen = Symbol(\"condExprSeen\");\n  const seqExprSeen = Symbol(\"seqExprSeen\");\n  const shouldRevisit = Symbol(\"shouldRevisit\");\n  return {\n    name: \"minify-simplify\",\n    visitor: {\n      Statement: {\n        exit(path) {\n          if (path.node[shouldRevisit]) {\n            delete path.node[shouldRevisit];\n            path.visit();\n          }\n        }\n\n      },\n      // CallExpression(path) {\n      // const { node } = path;\n\n      /* (function() {})() -> !function() {}()\n        There is a bug in babel in printing this. Disabling for now.\n        if (t.isFunctionExpression(node.callee) &&\n            (t.isExpressionStatement(parent) ||\n             (t.isSequenceExpression(parent) && parent.expressions[0] === node))\n        ) {\n          path.replaceWith(\n            t.callExpression(\n              t.unaryExpression(\"!\", node.callee, true),\n              node.arguments\n            )\n          );\n          return;\n        }*/\n      // },\n      UnaryExpression: {\n        enter: [// Demorgans.\n        function (path) {\n          const node = path.node;\n\n          if (node.operator !== \"!\" || flipExpressions.hasSeen(node)) {\n            return;\n          }\n\n          const expr = node.argument; // We need to make sure that the return type will always be boolean.\n\n          if (!(t.isLogicalExpression(expr) || t.isConditionalExpression(expr) || t.isBinaryExpression(expr))) {\n            return;\n          }\n\n          if (t.isBinaryExpression(expr) && t.COMPARISON_BINARY_OPERATORS.indexOf(expr.operator) === -1) {\n            return;\n          }\n\n          if (flipExpressions.shouldFlip(expr, 1)) {\n            const newNode = flipExpressions.flip(expr);\n            path.replaceWith(newNode);\n          }\n        }, // !(a, b, c) -> a, b, !c\n        function (path) {\n          const node = path.node;\n\n          if (node.operator !== \"!\") {\n            return;\n          }\n\n          if (!t.isSequenceExpression(node.argument)) {\n            return;\n          }\n\n          const seq = node.argument.expressions;\n          const expr = seq[seq.length - 1];\n          seq[seq.length - 1] = t.unaryExpression(\"!\", expr, true);\n          path.replaceWith(node.argument);\n        }, // !(a ? b : c) -> a ? !b : !c\n        function (path) {\n          const node = path.node;\n\n          if (node.operator !== \"!\") {\n            return;\n          }\n\n          if (!t.isConditional(node.argument)) {\n            return;\n          }\n\n          const cond = node.argument;\n          cond.alternate = t.unaryExpression(\"!\", cond.alternate, true);\n          cond.consequent = t.unaryExpression(\"!\", cond.consequent, true);\n          path.replaceWith(node.argument);\n        }]\n      },\n\n      BinaryExpression(path) {\n        if ([\"!=\", \"==\"].indexOf(path.node.operator) !== -1) {\n          undefinedToNull(path.get(\"left\"));\n          undefinedToNull(path.get(\"right\"));\n        }\n      },\n\n      LogicalExpression: {\n        exit: logicalExpression.simplifyPatterns\n      },\n      AssignmentExpression: assignmentExpression.simplify,\n      ConditionalExpression: {\n        enter: [// !foo ? 'foo' : 'bar' -> foo ? 'bar' : 'foo'\n        // foo !== 'lol' ? 'foo' : 'bar' -> foo === 'lol' ? 'bar' : 'foo'\n        function flipIfOrConditional(path) {\n          const node = path.node;\n\n          if (!path.get(\"test\").isLogicalExpression()) {\n            flipNegation(node);\n            return;\n          }\n\n          if (flipExpressions.shouldFlip(node.test)) {\n            node.test = flipExpressions.flip(node.test);\n            var _ref = [node.consequent, node.alternate];\n            node.alternate = _ref[0];\n            node.consequent = _ref[1];\n          }\n        }, conditionalExpression.simplifyPatterns],\n        exit: [// a ? x = foo : b ? x = bar : x = baz;\n        // x = a ? foo : b ? bar : baz;\n        function (topPath) {\n          if (!topPath.parentPath.isExpressionStatement() && !topPath.parentPath.isSequenceExpression()) {\n            return;\n          }\n\n          const mutations = [];\n          let firstLeft = null;\n          let operator = null;\n\n          function visit(path) {\n            if (path.isConditionalExpression()) {\n              let bail = visit(path.get(\"consequent\"));\n\n              if (bail) {\n                return true;\n              }\n\n              bail = visit(path.get(\"alternate\"));\n              return bail;\n            }\n\n            if (operator == null) {\n              operator = path.node.operator;\n            } else if (path.node.operator !== operator) {\n              return true;\n            }\n\n            if (!path.isAssignmentExpression() || !(path.get(\"left\").isIdentifier() || path.get(\"left\").isMemberExpression())) {\n              return true;\n            }\n\n            const left = path.get(\"left\").node;\n\n            if (firstLeft == null) {\n              firstLeft = left;\n            } else if (!t.isNodesEquivalent(left, firstLeft)) {\n              return true;\n            }\n\n            mutations.push(() => path.replaceWith(path.get(\"right\").node));\n          }\n\n          const bail = visit(topPath);\n\n          if (bail) {\n            return;\n          }\n\n          mutations.forEach(f => f());\n          topPath.replaceWith(t.assignmentExpression(operator, firstLeft, topPath.node));\n        }, // bar ? void 0 : void 0\n        // (bar, void 0)\n        // TODO: turn this into general equiv check\n        function (path) {\n          const node = path.node;\n\n          if (isVoid0(node.consequent) && isVoid0(node.alternate)) {\n            path.replaceWith(t.sequenceExpression([path.node.test, VOID_0]));\n          }\n        }, // bar ? void 0 : foo ? void 0 : <etc>\n        // bar || foo : void 0\n        // TODO: turn this into general equiv check\n        function (path) {\n          const node = path.node;\n\n          if (node[condExprSeen] || !isVoid0(node.consequent)) {\n            return;\n          }\n\n          node[condExprSeen] = true;\n          const tests = [node.test];\n          const mutations = [];\n          let alt;\n\n          for (let next = path.get(\"alternate\"); next.isConditionalExpression(); next = next.get(\"alternate\")) {\n            next.node[condExprSeen] = true;\n            alt = next.node.alternate;\n\n            if (isVoid0(next.node.consequent)) {\n              tests.push(next.node.test);\n              mutations.push(() => next.remove());\n            } else {\n              alt = next.node;\n              break;\n            }\n          }\n\n          if (tests.length === 1) {\n            return;\n          }\n\n          const test = tests.reduce((expr, curTest) => t.logicalExpression(\"||\", expr, curTest));\n          path.replaceWith(t.conditionalExpression(test, VOID_0, alt));\n        }]\n      },\n      // concat\n      VariableDeclaration: {\n        enter: [// Put vars with no init at the top.\n        function (path) {\n          const node = path.node;\n\n          if (node.declarations.length < 2) {\n            return;\n          }\n\n          const inits = [];\n          const empty = [];\n          var _iteratorNormalCompletion = true;\n          var _didIteratorError = false;\n          var _iteratorError = undefined;\n\n          try {\n            for (var _iterator = node.declarations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n              const decl = _step.value;\n\n              if (!decl.init) {\n                empty.push(decl);\n              } else {\n                inits.push(decl);\n              }\n            } // This is based on exprimintation but there is a significant\n            // imrpovement when we place empty vars at the top in smaller\n            // files. Whereas it hurts in larger files.\n\n          } catch (err) {\n            _didIteratorError = true;\n            _iteratorError = err;\n          } finally {\n            try {\n              if (!_iteratorNormalCompletion && _iterator.return != null) {\n                _iterator.return();\n              }\n            } finally {\n              if (_didIteratorError) {\n                throw _iteratorError;\n              }\n            }\n          }\n\n          if (this.fitsInSlidingWindow) {\n            node.declarations = empty.concat(inits);\n          } else {\n            node.declarations = inits.concat(empty);\n          }\n        }]\n      },\n      Function: {\n        exit(path) {\n          earlyReturnTransform(path);\n\n          if (!path.node[shouldRevisit]) {\n            return;\n          }\n\n          delete path.node[shouldRevisit];\n          path.visit();\n        }\n\n      },\n      For: {\n        enter: earlyContinueTransform,\n        exit: earlyContinueTransform\n      },\n      ForStatement: {\n        // Merge previous expressions in the init part of the for.\n        enter(path) {\n          const node = path.node;\n\n          if (!path.inList || node.init && !t.isExpression(node.init)) {\n            return;\n          }\n\n          const prev = path.getSibling(path.key - 1);\n          let consumed = false;\n\n          if (prev.isVariableDeclaration()) {\n            let referencedOutsideLoop = false; // we don't care if vars are referenced outside the loop as they are fn scope\n\n            if (prev.node.kind === \"let\" || prev.node.kind === \"const\") {\n              const ids = Object.keys(prev.getBindingIdentifiers());\n\n              idloop: for (let i = 0; i < ids.length; i++) {\n                const binding = prev.scope.bindings[ids[i]]; // TODO\n                // Temporary Fix\n                // if there is no binding, we assume it is referenced outside\n                // and deopt to avoid bugs\n\n                if (!binding) {\n                  referencedOutsideLoop = true;\n                  break idloop;\n                }\n\n                const refs = binding.referencePaths;\n\n                for (let j = 0; j < refs.length; j++) {\n                  if (!isAncestor(path, refs[j])) {\n                    referencedOutsideLoop = true;\n                    break idloop;\n                  }\n                }\n              }\n            }\n\n            if (!node.init && !referencedOutsideLoop) {\n              node.init = prev.node;\n              consumed = true;\n            }\n          } else if (prev.isExpressionStatement()) {\n            const expr = prev.node.expression;\n\n            if (node.init) {\n              if (t.isSequenceExpression(expr)) {\n                expr.expressions.push(node.init);\n                node.init = expr;\n              } else {\n                node.init = t.sequenceExpression([expr, node.init]);\n              }\n            } else {\n              node.init = expr;\n            }\n\n            consumed = true;\n          }\n\n          if (consumed) {\n            prev.remove();\n          }\n        },\n\n        exit(path) {\n          const node = path.node;\n\n          if (!node.test) {\n            return;\n          }\n\n          if (!path.get(\"body\").isBlockStatement()) {\n            const bodyNode = path.get(\"body\").node;\n\n            if (!t.isIfStatement(bodyNode)) {\n              return;\n            }\n\n            if (t.isBreakStatement(bodyNode.consequent, {\n              label: null\n            })) {\n              node.test = t.logicalExpression(\"&&\", node.test, t.unaryExpression(\"!\", bodyNode.test, true));\n              node.body = bodyNode.alternate || t.emptyStatement();\n              return;\n            }\n\n            if (t.isBreakStatement(bodyNode.alternate, {\n              label: null\n            })) {\n              node.test = t.logicalExpression(\"&&\", node.test, bodyNode.test);\n              node.body = bodyNode.consequent || t.emptyStatement();\n              return;\n            }\n\n            return;\n          }\n\n          const statements = node.body.body;\n          const exprs = [];\n          let ifStatement = null;\n          let breakAt = null;\n          let i = 0;\n\n          for (let statement; statement = statements[i]; i++) {\n            if (t.isIfStatement(statement)) {\n              if (t.isBreakStatement(statement.consequent, {\n                label: null\n              })) {\n                ifStatement = statement;\n                breakAt = \"consequent\";\n              } else if (t.isBreakStatement(statement.alternate, {\n                label: null\n              })) {\n                ifStatement = statement;\n                breakAt = \"alternate\";\n              }\n\n              break;\n            } // A statement appears before the break statement then bail.\n\n\n            if (!t.isExpressionStatement(statement)) {\n              return;\n            }\n\n            exprs.push(statement.expression);\n          }\n\n          if (!ifStatement) {\n            return;\n          }\n\n          const rest = [];\n\n          if (breakAt === \"consequent\") {\n            if (t.isBlockStatement(ifStatement.alternate)) {\n              rest.push(...ifStatement.alternate.body);\n            } else if (ifStatement.alternate) {\n              rest.push(ifStatement.alternate);\n            }\n          } else {\n            if (t.isBlockStatement(ifStatement.consequent)) {\n              rest.push(...ifStatement.consequent.body);\n            } else if (ifStatement.consequent) {\n              rest.push(ifStatement.consequent);\n            }\n          }\n\n          rest.push(...statements.slice(i + 1));\n          const test = breakAt === \"consequent\" ? t.unaryExpression(\"!\", ifStatement.test, true) : ifStatement.test;\n          let expr;\n\n          if (exprs.length === 1) {\n            expr = t.sequenceExpression([exprs[0], test]);\n          } else if (exprs.length) {\n            exprs.push(test);\n            expr = t.sequenceExpression(exprs);\n          } else {\n            expr = test;\n          }\n\n          node.test = t.logicalExpression(\"&&\", node.test, expr);\n\n          if (rest.length === 1) {\n            node.body = rest[0];\n          } else if (rest.length) {\n            node.body = t.blockStatement(rest);\n          } else {\n            node.body = t.emptyStatement();\n          }\n        }\n\n      },\n\n      Program(path) {\n        // An approximation of the resultant gzipped code after minification\n        this.fitsInSlidingWindow = path.getSource().length / 10 < 33000;\n        const node = path.node;\n        const statements = toMultipleSequenceExpressions(node.body);\n\n        if (!statements.length) {\n          return;\n        }\n\n        node.body = statements;\n      },\n\n      BlockStatement: {\n        enter(path) {\n          const node = path.node,\n                parent = path.parent;\n          const top = [];\n          const bottom = [];\n\n          for (let i = 0; i < node.body.length; i++) {\n            const bodyNode = node.body[i];\n\n            if (t.isFunctionDeclaration(bodyNode)) {\n              top.push(bodyNode);\n            } else {\n              bottom.push(bodyNode);\n            }\n          }\n\n          const statements = top.concat(toMultipleSequenceExpressions(bottom));\n\n          if (!statements.length) {\n            return;\n          }\n\n          if (statements.length > 1 || needsBlock(node, parent) || node.directives) {\n            node.body = statements;\n            return;\n          }\n\n          if (statements.length) {\n            path.replaceWith(statements[0]);\n            return;\n          }\n        },\n\n        exit(path) {\n          const node = path.node,\n                parent = path.parent;\n\n          if (t.isArrowFunctionExpression(parent) && node.body.length === 1 && t.isReturnStatement(node.body[0]) && node.body[0].argument !== null) {\n            path.replaceWith(node.body[0].argument);\n            return;\n          }\n\n          if (needsBlock(node, parent)) {\n            return;\n          }\n\n          if (node.body.length === 1) {\n            path.get(\"body\")[0].inList = false;\n            path.replaceWith(node.body[0]);\n            return;\n          }\n\n          if (node.body.length === 0) {\n            path.replaceWith(t.emptyStatement());\n            return;\n          } // Check if oppurtinties to merge statements are available.\n\n\n          const statements = node.body;\n\n          if (!statements.length) {\n            return;\n          }\n\n          var _iteratorNormalCompletion2 = true;\n          var _didIteratorError2 = false;\n          var _iteratorError2 = undefined;\n\n          try {\n            for (var _iterator2 = statements[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n              const statement = _step2.value;\n\n              if (!t.isExpressionStatement(statement)) {\n                return;\n              }\n            }\n          } catch (err) {\n            _didIteratorError2 = true;\n            _iteratorError2 = err;\n          } finally {\n            try {\n              if (!_iteratorNormalCompletion2 && _iterator2.return != null) {\n                _iterator2.return();\n              }\n            } finally {\n              if (_didIteratorError2) {\n                throw _iteratorError2;\n              }\n            }\n          }\n\n          path.visit();\n        }\n\n      },\n      ThrowStatement: createPrevExpressionEater(\"throw\"),\n      // Try to merge previous statements into a sequence\n      ReturnStatement: {\n        enter: [createPrevExpressionEater(\"return\"), // Remove return if last statement with no argument.\n        // Replace return with `void` argument with argument.\n        function (path) {\n          const node = path.node;\n\n          if (!path.parentPath.parentPath.isFunction() || path.getSibling(path.key + 1).node) {\n            return;\n          }\n\n          if (!node.argument) {\n            path.remove();\n            return;\n          }\n\n          if (t.isUnaryExpression(node.argument, {\n            operator: \"void\"\n          })) {\n            path.replaceWith(node.argument.argument);\n          }\n        }]\n      },\n      // turn blocked ifs into single statements\n      IfStatement: {\n        exit: [ifStatement.mergeNestedIfs, ifStatement.simplify, ifStatement.switchConsequent, ifStatement.conditionalReturnToGuards, createPrevExpressionEater(\"if\")]\n      },\n\n      WhileStatement(path) {\n        const node = path.node;\n        path.replaceWith(t.forStatement(null, node.test, null, node.body));\n      },\n\n      ForInStatement: createPrevExpressionEater(\"for-in\"),\n      // Flatten sequence expressions.\n      SequenceExpression: {\n        exit(path) {\n          if (path.node[seqExprSeen]) {\n            return;\n          }\n\n          function flatten(node) {\n            node[seqExprSeen] = true;\n            const ret = [];\n            var _iteratorNormalCompletion3 = true;\n            var _didIteratorError3 = false;\n            var _iteratorError3 = undefined;\n\n            try {\n              for (var _iterator3 = node.expressions[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {\n                const n = _step3.value;\n\n                if (t.isSequenceExpression(n)) {\n                  ret.push(...flatten(n));\n                } else {\n                  ret.push(n);\n                }\n              }\n            } catch (err) {\n              _didIteratorError3 = true;\n              _iteratorError3 = err;\n            } finally {\n              try {\n                if (!_iteratorNormalCompletion3 && _iterator3.return != null) {\n                  _iterator3.return();\n                }\n              } finally {\n                if (_didIteratorError3) {\n                  throw _iteratorError3;\n                }\n              }\n            }\n\n            return ret;\n          }\n\n          path.node.expressions = flatten(path.node);\n        }\n\n      },\n\n      SwitchCase(path) {\n        const node = path.node;\n\n        if (!node.consequent.length) {\n          return;\n        }\n\n        node.consequent = toMultipleSequenceExpressions(node.consequent);\n      },\n\n      SwitchStatement: {\n        exit: [// Convert switch statements with all returns in their cases\n        // to return conditional.\n        function (path) {\n          const node = path.node; // Need to be careful of side-effects.\n\n          if (!t.isIdentifier(node.discriminant)) {\n            return;\n          }\n\n          if (!node.cases.length) {\n            return;\n          }\n\n          const consTestPairs = [];\n          let fallThru = [];\n          let defaultRet;\n          var _iteratorNormalCompletion4 = true;\n          var _didIteratorError4 = false;\n          var _iteratorError4 = undefined;\n\n          try {\n            for (var _iterator4 = node.cases[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {\n              const switchCase = _step4.value;\n\n              if (switchCase.consequent.length > 1) {\n                return;\n              }\n\n              const cons = switchCase.consequent[0]; // default case\n\n              if (!switchCase.test) {\n                if (!t.isReturnStatement(cons)) {\n                  return;\n                }\n\n                defaultRet = cons;\n                continue;\n              }\n\n              if (!switchCase.consequent.length) {\n                fallThru.push(switchCase.test);\n                continue;\n              } // TODO: can we void it?\n\n\n              if (!t.isReturnStatement(cons)) {\n                return;\n              }\n\n              let test = t.binaryExpression(\"===\", node.discriminant, switchCase.test);\n\n              if (fallThru.length && !defaultRet) {\n                test = fallThru.reduceRight((right, test) => t.logicalExpression(\"||\", t.binaryExpression(\"===\", node.discriminant, test), right), test);\n              }\n\n              fallThru = [];\n              consTestPairs.push([test, cons.argument || VOID_0]);\n            } // Bail if we have any remaining fallthrough\n\n          } catch (err) {\n            _didIteratorError4 = true;\n            _iteratorError4 = err;\n          } finally {\n            try {\n              if (!_iteratorNormalCompletion4 && _iterator4.return != null) {\n                _iterator4.return();\n              }\n            } finally {\n              if (_didIteratorError4) {\n                throw _iteratorError4;\n              }\n            }\n          }\n\n          if (fallThru.length) {\n            return;\n          } // We need the default to be there to make sure there is an oppurtinity\n          // not to return.\n\n\n          if (!defaultRet) {\n            if (path.inList) {\n              const nextPath = path.getSibling(path.key + 1);\n\n              if (nextPath.isReturnStatement()) {\n                defaultRet = nextPath.node;\n                nextPath.remove();\n              } else if (!nextPath.node && path.parentPath.parentPath.isFunction()) {\n                // If this is the last statement in a function we just fake a void return.\n                defaultRet = t.returnStatement(VOID_0);\n              } else {\n                return;\n              }\n            } else {\n              return;\n            }\n          }\n\n          const cond = consTestPairs.reduceRight((alt, [test, cons]) => t.conditionalExpression(test, cons, alt), defaultRet.argument || VOID_0);\n          path.replaceWith(t.returnStatement(cond)); // Maybe now we can merge with some previous switch statement.\n\n          if (path.inList) {\n            const prev = path.getSibling(path.key - 1);\n\n            if (prev.isSwitchStatement()) {\n              prev.visit();\n            }\n          }\n        }, // Convert switches into conditionals.\n        function (path) {\n          const node = path.node; // Need to be careful of side-effects.\n\n          if (!t.isIdentifier(node.discriminant)) {\n            return;\n          }\n\n          if (!node.cases.length) {\n            return;\n          }\n\n          const exprTestPairs = [];\n          let fallThru = [];\n          let defaultExpr;\n          var _iteratorNormalCompletion5 = true;\n          var _didIteratorError5 = false;\n          var _iteratorError5 = undefined;\n\n          try {\n            for (var _iterator5 = node.cases[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {\n              const switchCase = _step5.value;\n\n              if (!switchCase.test) {\n                if (switchCase.consequent.length !== 1) {\n                  return;\n                }\n\n                if (!t.isExpressionStatement(switchCase.consequent[0])) {\n                  return;\n                }\n\n                defaultExpr = switchCase.consequent[0].expression;\n                continue;\n              }\n\n              if (!switchCase.consequent.length) {\n                fallThru.push(switchCase.test);\n                continue;\n              }\n\n              const _switchCase$consequen = _slicedToArray(switchCase.consequent, 2),\n                    cons = _switchCase$consequen[0],\n                    breakStatement = _switchCase$consequen[1];\n\n              if (switchCase === node.cases[node.cases.length - 1]) {\n                if (breakStatement && !t.isBreakStatement(breakStatement)) {\n                  return;\n                }\n              } else if (!t.isBreakStatement(breakStatement)) {\n                return;\n              }\n\n              if (!t.isExpressionStatement(cons) || switchCase.consequent.length > 2) {\n                return;\n              }\n\n              let test = t.binaryExpression(\"===\", node.discriminant, switchCase.test);\n\n              if (fallThru.length && !defaultExpr) {\n                test = fallThru.reduceRight((right, test) => t.logicalExpression(\"||\", t.binaryExpression(\"===\", node.discriminant, test), right), test);\n              }\n\n              fallThru = [];\n              exprTestPairs.push([test, cons.expression]);\n            }\n          } catch (err) {\n            _didIteratorError5 = true;\n            _iteratorError5 = err;\n          } finally {\n            try {\n              if (!_iteratorNormalCompletion5 && _iterator5.return != null) {\n                _iterator5.return();\n              }\n            } finally {\n              if (_didIteratorError5) {\n                throw _iteratorError5;\n              }\n            }\n          }\n\n          if (fallThru.length) {\n            return;\n          }\n\n          const cond = exprTestPairs.reduceRight((alt, [test, cons]) => t.conditionalExpression(test, cons, alt), defaultExpr || VOID_0);\n          path.replaceWith(cond);\n        }, function (path) {\n          const node = path.node;\n\n          if (!node.cases.length) {\n            return;\n          }\n\n          const lastCase = path.get(\"cases\")[node.cases.length - 1];\n\n          if (!lastCase.node.consequent.length) {\n            return;\n          }\n\n          const potentialBreak = lastCase.get(\"consequent\")[lastCase.node.consequent.length - 1];\n\n          if (t.isBreakStatement(potentialBreak) && potentialBreak.node.label === null) {\n            potentialBreak.remove();\n          }\n        }, createPrevExpressionEater(\"switch\")]\n      }\n    }\n  };\n\n  function flipNegation(node) {\n    if (!node.consequent || !node.alternate) {\n      return;\n    }\n\n    const test = node.test;\n    let flip = false;\n\n    if (t.isBinaryExpression(test)) {\n      if (test.operator === \"!==\") {\n        test.operator = \"===\";\n        flip = true;\n      }\n\n      if (test.operator === \"!=\") {\n        test.operator = \"==\";\n        flip = true;\n      }\n    }\n\n    if (t.isUnaryExpression(test, {\n      operator: \"!\"\n    })) {\n      node.test = test.argument;\n      flip = true;\n    }\n\n    if (flip) {\n      const consequent = node.consequent;\n      node.consequent = node.alternate;\n      node.alternate = consequent;\n    }\n  }\n\n  function needsBlock(node, parent) {\n    return t.isFunction(parent) && node === parent.body || t.isTryStatement(parent) || t.isCatchClause(parent) || t.isSwitchStatement(parent) || isSingleBlockScopeDeclaration(node) && (t.isIfStatement(parent) || t.isLoop(parent));\n  }\n\n  function isSingleBlockScopeDeclaration(block) {\n    return t.isBlockStatement(block) && block.body.length === 1 && (t.isVariableDeclaration(block.body[0], {\n      kind: \"let\"\n    }) || t.isVariableDeclaration(block.body[0], {\n      kind: \"const\"\n    }) || t.isFunctionDeclaration(block.body[0]));\n  }\n\n  function isVoid0(expr) {\n    return expr === VOID_0 || t.isUnaryExpression(expr, {\n      operator: \"void\"\n    }) && t.isNumericLiteral(expr.argument, {\n      value: 0\n    });\n  }\n\n  function earlyReturnTransform(path) {\n    const block = path.get(\"body\");\n\n    if (!block.isBlockStatement()) {\n      return;\n    }\n\n    const body = block.get(\"body\");\n\n    for (let i = body.length - 1; i >= 0; i--) {\n      const statement = body[i];\n\n      if (t.isIfStatement(statement.node) && !statement.node.alternate && t.isReturnStatement(statement.node.consequent) && !statement.node.consequent.argument) {\n        genericEarlyExitTransform(statement);\n      }\n    }\n  }\n\n  function earlyContinueTransform(path) {\n    const block = path.get(\"body\");\n\n    if (!block.isBlockStatement()) {\n      return;\n    }\n\n    let body = block.get(\"body\");\n\n    for (let i = body.length - 1; i >= 0; i--) {\n      const statement = body[i];\n\n      if (t.isIfStatement(statement.node) && !statement.node.alternate && t.isContinueStatement(statement.node.consequent) && !statement.node.consequent.label) {\n        genericEarlyExitTransform(statement);\n      }\n    } // because we might have folded or removed statements\n\n\n    body = block.get(\"body\"); // We may have reduced the body to a single statement.\n\n    if (body.length === 1 && !needsBlock(block.node, path.node)) {\n      block.replaceWith(body[0].node);\n    }\n  }\n\n  function genericEarlyExitTransform(path) {\n    const node = path.node;\n    const statements = path.parentPath.get(path.listKey).slice(path.key + 1).filter(stmt => !stmt.isFunctionDeclaration()); // deopt for any block scoped bindings\n    // issue#399\n\n    const deopt = !statements.every(stmt => {\n      if (!(stmt.isVariableDeclaration({\n        kind: \"let\"\n      }) || stmt.isVariableDeclaration({\n        kind: \"const\"\n      }))) {\n        return true;\n      }\n\n      const ids = Object.keys(stmt.getBindingIdentifiers());\n\n      for (var _i2 = 0; _i2 < ids.length; _i2++) {\n        const id = ids[_i2];\n        const binding = path.scope.getBinding(id); // TODO\n        // Temporary Fix\n        // if there is no binding, we assume it is referenced outside\n        // and deopt to avoid bugs\n\n        if (!binding) {\n          return false;\n        }\n\n        const refs = [...binding.referencePaths, ...binding.constantViolations];\n\n        for (var _i3 = 0; _i3 < refs.length; _i3++) {\n          const ref = refs[_i3];\n          if (!ref.isIdentifier()) return false;\n          const fnParent = ref.getFunctionParent(); // TODO\n          // Usage of scopes and bindings in simplify plugin results in\n          // undefined bindings because scope changes are not updated in the\n          // scope tree. So, we deopt whenever we encounter one such issue\n          // and not perform the transformation\n\n          if (!fnParent) {\n            return false;\n          }\n\n          if (fnParent.scope !== path.scope) return false;\n        }\n      }\n\n      return true;\n    });\n\n    if (deopt) {\n      path.visit();\n      return false;\n    }\n\n    if (!statements.length) {\n      path.replaceWith(t.expressionStatement(node.test));\n      return;\n    }\n\n    const test = node.test;\n\n    if (t.isBinaryExpression(test) && test.operator === \"!==\") {\n      test.operator = \"===\";\n    } else if (t.isBinaryExpression(test) && test.operator === \"!=\") {\n      test.operator = \"==\";\n    } else if (t.isUnaryExpression(test, {\n      operator: \"!\"\n    })) {\n      node.test = test.argument;\n    } else {\n      node.test = t.unaryExpression(\"!\", node.test, true);\n    }\n\n    path.get(\"consequent\").replaceWith(t.blockStatement(statements.map(stmt => t.clone(stmt.node))));\n    let l = statements.length;\n\n    while (l-- > 0) {\n      if (!statements[l].isFunctionDeclaration()) {\n        path.getSibling(path.key + 1).remove();\n      }\n    } // this should take care of removing the block\n\n\n    path.visit();\n  }\n\n  function createPrevExpressionEater(keyword) {\n    let key;\n\n    switch (keyword) {\n      case \"switch\":\n        key = \"discriminant\";\n        break;\n\n      case \"throw\":\n      case \"return\":\n        key = \"argument\";\n        break;\n\n      case \"if\":\n        key = \"test\";\n        break;\n\n      case \"for-in\":\n        key = \"right\";\n        break;\n    }\n\n    return function (path) {\n      if (!path.inList) {\n        return;\n      }\n\n      const node = path.node;\n      const prev = path.getSibling(path.key - 1);\n\n      if (!prev.isExpressionStatement()) {\n        return;\n      }\n\n      let seq = prev.node.expression;\n\n      if (node[key]) {\n        if (t.isSequenceExpression(seq)) {\n          seq.expressions.push(node[key]);\n        } else {\n          seq = t.sequenceExpression([seq, node[key]]);\n        }\n      } else {\n        if (t.isSequenceExpression(seq)) {\n          const lastExpr = seq.expressions[seq.expressions.length - 1];\n          seq.expressions[seq.expressions.length - 1] = t.unaryExpression(\"void\", lastExpr, true);\n        } else {\n          seq = t.unaryExpression(\"void\", seq, true);\n        }\n      }\n\n      if (seq) {\n        node[key] = seq;\n        prev.remove(); // Since we were able to merge some stuff it's possible that this has opened\n        // oppurtinties for other transforms to happen.\n        // TODO: Look into changing the traversal order from bottom to up to avoid\n        // having to revisit things.\n\n        if (path.parentPath.parent) {\n          path.parentPath.parent[shouldRevisit] = true;\n        }\n      }\n    };\n  } // path1 -> path2\n  // is path1 an ancestor of path2\n\n\n  function isAncestor(path1, path2) {\n    return !!path2.findParent(parent => parent === path1);\n  }\n\n  function isPureVoid(path) {\n    return path.isUnaryExpression({\n      operator: \"void\"\n    }) && path.isPure();\n  }\n\n  function isGlobalUndefined(path) {\n    return path.isIdentifier({\n      name: \"undefined\"\n    }) && !path.scope.getBinding(\"undefined\");\n  }\n\n  function undefinedToNull(path) {\n    if (isGlobalUndefined(path) || isPureVoid(path)) {\n      path.replaceWith(t.nullLiteral());\n    }\n  }\n};","var castPath = require('./_castPath'),\n    toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.get` without support for default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @returns {*} Returns the resolved value.\n */\nfunction baseGet(object, path) {\n  path = castPath(path, object);\n\n  var index = 0,\n      length = path.length;\n\n  while (object != null && index < length) {\n    object = object[toKey(path[index++])];\n  }\n  return (index && index == length) ? object : undefined;\n}\n\nmodule.exports = baseGet;\n","\"use strict\"; // Assuming all the static methods from below array are side effect free evaluation\n// except Math.random\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); }\n\nfunction _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nconst VALID_CALLEES = [\"String\", \"Number\", \"Math\"];\nconst INVALID_METHODS = [\"random\"];\nconst newIssueUrl = \"https://github.com/babel/minify/issues/new\";\n\nmodule.exports = function ({\n  types: t\n}) {\n  class BuiltInReplacer {\n    constructor() {\n      // map<expr_name, path[]>;\n      this.pathsToUpdate = new Map();\n    }\n\n    getCollectVisitor() {\n      const context = this;\n      const collectVisitor = {\n        AssignmentExpression(path) {\n          const left = path.node.left; // Should bail and not run the plugin\n          // when builtin is polyfilled\n\n          if (t.isMemberExpression(left) && isBuiltInComputed(left)) {\n            let parent = path;\n\n            do {\n              parent.stop();\n            } while (parent = parent.parentPath);\n          }\n        },\n\n        MemberExpression(path) {\n          if (path.parentPath.isCallExpression()) {\n            return;\n          }\n\n          const node = path.node;\n\n          if (!isComputed(node) && isBuiltin(node) && !getFunctionParent(path).isProgram()) {\n            const expName = memberToString(node);\n            addToMap(context.pathsToUpdate, expName, path);\n          }\n        },\n\n        CallExpression: {\n          exit(path) {\n            const callee = path.get(\"callee\");\n\n            if (!callee.isMemberExpression()) {\n              return;\n            }\n\n            const node = callee.node; // computed property should not be optimized\n            // Math[max]() -> Math.max()\n\n            if (!isComputed(node) && isBuiltin(node) && !getFunctionParent(callee).isProgram()) {\n              const expName = memberToString(node);\n              addToMap(context.pathsToUpdate, expName, callee);\n            }\n          }\n\n        }\n      };\n      return collectVisitor;\n    }\n\n    replace() {\n      var _iteratorNormalCompletion = true;\n      var _didIteratorError = false;\n      var _iteratorError = undefined;\n\n      try {\n        for (var _iterator = this.pathsToUpdate[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n          const _step$value = _slicedToArray(_step.value, 2),\n                expName = _step$value[0],\n                paths = _step$value[1];\n\n          // transform only if there is more than 1 occurence\n          if (paths.length <= 1) {\n            continue;\n          }\n\n          const segmentsMap = getSegmentedSubPaths(paths);\n          var _iteratorNormalCompletion2 = true;\n          var _didIteratorError2 = false;\n          var _iteratorError2 = undefined;\n\n          try {\n            for (var _iterator2 = segmentsMap[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n              const _step2$value = _slicedToArray(_step2.value, 2),\n                    parent = _step2$value[0],\n                    subpaths = _step2$value[1];\n\n              if (subpaths.length <= 1) {\n                continue;\n              }\n\n              const uniqueIdentifier = parent.scope.generateUidIdentifier(expName);\n              const newNode = t.variableDeclaration(\"var\", [t.variableDeclarator(uniqueIdentifier, subpaths[0].node)]);\n              var _iteratorNormalCompletion3 = true;\n              var _didIteratorError3 = false;\n              var _iteratorError3 = undefined;\n\n              try {\n                for (var _iterator3 = subpaths[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {\n                  const path = _step3.value;\n                  path.replaceWith(t.clone(uniqueIdentifier));\n                } // hoist the created var to the top of the function scope\n\n              } catch (err) {\n                _didIteratorError3 = true;\n                _iteratorError3 = err;\n              } finally {\n                try {\n                  if (!_iteratorNormalCompletion3 && _iterator3.return != null) {\n                    _iterator3.return();\n                  }\n                } finally {\n                  if (_didIteratorError3) {\n                    throw _iteratorError3;\n                  }\n                }\n              }\n\n              const target = parent.get(\"body\");\n              /**\n               * Here, we validate a case where there is a local binding of\n               * one of Math, String or Number. Here we have to get the\n               * global Math instead of using the local one - so we do the\n               * following transformation\n               *\n               * var _Mathmax = Math.max;\n               *\n               * to\n               *\n               * var _Mathmax = (0, eval)(\"this\").Math.max;\n               */\n\n              for (var _i2 = 0; _i2 < VALID_CALLEES.length; _i2++) {\n                const builtin = VALID_CALLEES[_i2];\n\n                if (target.scope.getBinding(builtin)) {\n                  const prev = newNode.declarations[0].init;\n\n                  if (!t.isMemberExpression(prev)) {\n                    throw new Error(`minify-builtins expected a MemberExpression. ` + `Found ${prev.type}. ` + `Please report this at ${newIssueUrl}`);\n                  }\n\n                  if (!t.isMemberExpression(prev.object)) {\n                    newNode.declarations[0].init = t.memberExpression(t.memberExpression(getGlobalThis(), prev.object), prev.property);\n                  }\n                }\n              }\n\n              target.unshiftContainer(\"body\", newNode);\n            }\n          } catch (err) {\n            _didIteratorError2 = true;\n            _iteratorError2 = err;\n          } finally {\n            try {\n              if (!_iteratorNormalCompletion2 && _iterator2.return != null) {\n                _iterator2.return();\n              }\n            } finally {\n              if (_didIteratorError2) {\n                throw _iteratorError2;\n              }\n            }\n          }\n        }\n      } catch (err) {\n        _didIteratorError = true;\n        _iteratorError = err;\n      } finally {\n        try {\n          if (!_iteratorNormalCompletion && _iterator.return != null) {\n            _iterator.return();\n          }\n        } finally {\n          if (_didIteratorError) {\n            throw _iteratorError;\n          }\n        }\n      }\n    }\n\n  }\n\n  const builtInReplacer = new BuiltInReplacer();\n  return {\n    name: \"minify-builtins\",\n    visitor: Object.assign({}, builtInReplacer.getCollectVisitor(), {\n      Program: {\n        exit() {\n          builtInReplacer.replace();\n        }\n\n      }\n    })\n  };\n\n  function memberToString(memberExprNode) {\n    const object = memberExprNode.object,\n          property = memberExprNode.property;\n    let result = \"\";\n    if (t.isIdentifier(object)) result += object.name;\n    if (t.isMemberExpression(object)) result += memberToString(object);\n    if (t.isIdentifier(property)) result += property.name;\n    return result;\n  }\n\n  function isBuiltInComputed(memberExprNode) {\n    const object = memberExprNode.object,\n          computed = memberExprNode.computed;\n    return computed && t.isIdentifier(object) && VALID_CALLEES.indexOf(object.name) >= 0;\n  }\n\n  function isBuiltin(memberExprNode) {\n    const object = memberExprNode.object,\n          property = memberExprNode.property;\n\n    if (t.isIdentifier(object) && t.isIdentifier(property) && VALID_CALLEES.indexOf(object.name) >= 0 && INVALID_METHODS.indexOf(property.name) < 0) {\n      return true;\n    }\n\n    return false;\n  } // Creates a segmented map that contains the earliest common Ancestor\n  // as the key and array of subpaths that are descendats of the LCA as value\n\n\n  function getSegmentedSubPaths(paths) {\n    let segments = new Map(); // Get earliest Path in tree where paths intersect\n\n    paths[0].getDeepestCommonAncestorFrom(paths, (lastCommon, index, ancestries) => {\n      // found the LCA\n      if (!lastCommon.isProgram()) {\n        let fnParent;\n\n        if (lastCommon.isFunction() && t.isBlockStatement(lastCommon.node.body)) {\n          segments.set(lastCommon, paths);\n          return;\n        } else if (!(fnParent = getFunctionParent(lastCommon)).isProgram() && t.isBlockStatement(fnParent.node.body)) {\n          segments.set(fnParent, paths);\n          return;\n        }\n      } // Deopt and construct segments otherwise\n\n\n      var _iteratorNormalCompletion4 = true;\n      var _didIteratorError4 = false;\n      var _iteratorError4 = undefined;\n\n      try {\n        for (var _iterator4 = ancestries[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {\n          const ancestor = _step4.value;\n          const fnPath = getChildFuncion(ancestor);\n\n          if (fnPath === void 0) {\n            continue;\n          }\n\n          const validDescendants = paths.filter(p => {\n            return p.isDescendant(fnPath);\n          });\n          segments.set(fnPath, validDescendants);\n        }\n      } catch (err) {\n        _didIteratorError4 = true;\n        _iteratorError4 = err;\n      } finally {\n        try {\n          if (!_iteratorNormalCompletion4 && _iterator4.return != null) {\n            _iterator4.return();\n          }\n        } finally {\n          if (_didIteratorError4) {\n            throw _iteratorError4;\n          }\n        }\n      }\n    });\n    return segments;\n  }\n\n  function getChildFuncion(ancestors = []) {\n    var _iteratorNormalCompletion5 = true;\n    var _didIteratorError5 = false;\n    var _iteratorError5 = undefined;\n\n    try {\n      for (var _iterator5 = ancestors[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {\n        const path = _step5.value;\n\n        if (path.isFunction() && t.isBlockStatement(path.node.body)) {\n          return path;\n        }\n      }\n    } catch (err) {\n      _didIteratorError5 = true;\n      _iteratorError5 = err;\n    } finally {\n      try {\n        if (!_iteratorNormalCompletion5 && _iterator5.return != null) {\n          _iterator5.return();\n        }\n      } finally {\n        if (_didIteratorError5) {\n          throw _iteratorError5;\n        }\n      }\n    }\n  }\n  /**\n   * returns\n   *\n   * (0, eval)(\"this\")\n   */\n\n\n  function getGlobalThis() {\n    return t.callExpression(t.sequenceExpression([t.valueToNode(0), t.identifier(\"eval\")]), [t.valueToNode(\"this\")]);\n  }\n};\n\nfunction addToMap(map, key, value) {\n  if (!map.has(key)) {\n    map.set(key, []);\n  }\n\n  map.get(key).push(value);\n}\n\nfunction isComputed(node) {\n  return node.computed;\n}\n/**\n * Babel-7 returns null if there is no function parent\n * and uses getProgramParent to get Program\n */\n\n\nfunction getFunctionParent(path) {\n  return (path.scope.getFunctionParent() || path.scope.getProgramParent()).path;\n}","\"use strict\";\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\n\nmodule.exports = function bfsTraverseCreator({\n  types: t,\n  traverse\n}) {\n  function getFields(path) {\n    return t.VISITOR_KEYS[path.type];\n  }\n\n  return function bfsTraverse(path, _visitor) {\n    if (!path.node) {\n      throw new Error(\"Not a valid path\");\n    }\n\n    const visitor = traverse.explode(_visitor);\n    const queue = [path];\n    let current;\n\n    while (queue.length > 0) {\n      current = queue.shift(); // call\n\n      if (visitor && visitor[current.type] && Array.isArray(visitor[current.type].enter)) {\n        const fns = visitor[current.type].enter;\n\n        var _iterator = _createForOfIteratorHelper(fns),\n            _step;\n\n        try {\n          for (_iterator.s(); !(_step = _iterator.n()).done;) {\n            const fn = _step.value;\n            if (typeof fn === \"function\") fn(current);\n          }\n        } catch (err) {\n          _iterator.e(err);\n        } finally {\n          _iterator.f();\n        }\n      }\n\n      const fields = getFields(current);\n\n      var _iterator2 = _createForOfIteratorHelper(fields),\n          _step2;\n\n      try {\n        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n          const field = _step2.value;\n          const child = current.get(field);\n\n          if (Array.isArray(child)) {\n            // visit container left to right\n            var _iterator3 = _createForOfIteratorHelper(child),\n                _step3;\n\n            try {\n              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n                const c = _step3.value;\n                if (c.node) queue.push(c);\n              }\n            } catch (err) {\n              _iterator3.e(err);\n            } finally {\n              _iterator3.f();\n            }\n          } else {\n            if (child.node) queue.push(child);\n          }\n        }\n      } catch (err) {\n        _iterator2.e(err);\n      } finally {\n        _iterator2.f();\n      }\n    }\n  };\n};","/*\n  Copyright (C) 2013 Yusuke Suzuki <utatane.tea@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n\n(function () {\n    'use strict';\n\n    exports.ast = require('./ast');\n    exports.code = require('./code');\n    exports.keyword = require('./keyword');\n}());\n/* vim: set sw=4 ts=4 et tw=80 : */\n","\"use strict\";\n\nconst operators = new Set([\"+\", \"-\", \"*\", \"%\", \"<<\", \">>\", \">>>\", \"&\", \"|\", \"^\", \"/\", \"**\"]);\nconst updateOperators = new Set([\"+\", \"-\"]);\n\nmodule.exports = t => {\n  function simplify(path) {\n    const rightExpr = path.get(\"right\");\n    const leftExpr = path.get(\"left\");\n\n    if (path.node.operator !== \"=\") {\n      return;\n    }\n\n    const canBeUpdateExpression = rightExpr.get(\"right\").isNumericLiteral() && rightExpr.get(\"right\").node.value === 1 && updateOperators.has(rightExpr.node.operator);\n\n    if (leftExpr.isMemberExpression()) {\n      const leftPropNames = getPropNames(leftExpr);\n      const rightPropNames = getPropNames(rightExpr.get(\"left\"));\n\n      if (!leftPropNames || leftPropNames.indexOf(undefined) > -1 || !rightPropNames || rightPropNames.indexOf(undefined) > -1 || !operators.has(rightExpr.node.operator) || !areArraysEqual(leftPropNames, rightPropNames)) {\n        return;\n      }\n    } else {\n      if (!rightExpr.isBinaryExpression() || !operators.has(rightExpr.node.operator) || leftExpr.node.name !== rightExpr.node.left.name) {\n        return;\n      }\n    }\n\n    let newExpression; // special case x=x+1 --> ++x\n\n    if (canBeUpdateExpression) {\n      newExpression = t.updateExpression(rightExpr.node.operator + rightExpr.node.operator, t.clone(leftExpr.node), true\n      /* prefix */\n      );\n    } else {\n      newExpression = t.assignmentExpression(rightExpr.node.operator + \"=\", t.clone(leftExpr.node), t.clone(rightExpr.node.right));\n    }\n\n    path.replaceWith(newExpression);\n  }\n\n  return {\n    simplify\n  };\n};\n\nfunction areArraysEqual(arr1, arr2) {\n  return arr1.every((value, index) => {\n    return String(value) === String(arr2[index]);\n  });\n}\n\nfunction getPropNames(path) {\n  if (!path.isMemberExpression()) {\n    return;\n  }\n\n  let obj = path.get(\"object\");\n  const prop = path.get(\"property\");\n  const propNames = [getName(prop.node)];\n\n  while (obj.type === \"MemberExpression\") {\n    const node = obj.get(\"property\").node;\n\n    if (node) {\n      propNames.push(getName(node));\n    }\n\n    obj = obj.get(\"object\");\n  }\n\n  propNames.push(getName(obj.node));\n  return propNames;\n}\n\nfunction getName(node) {\n  if (node.type === \"ThisExpression\") {\n    return \"this\";\n  }\n\n  if (node.type === \"Super\") {\n    return \"super\";\n  }\n\n  if (node.type === \"NullLiteral\") {\n    return \"null\";\n  } // augment identifiers so that they don't match\n  // string/number literals\n  // but still match against each other\n\n\n  return node.name ? node.name + \"_\" : node.value\n  /* Literal */\n  ;\n}","var Stack = require('./_Stack'),\n    equalArrays = require('./_equalArrays'),\n    equalByTag = require('./_equalByTag'),\n    equalObjects = require('./_equalObjects'),\n    getTag = require('./_getTag'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isTypedArray = require('./isTypedArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n  var objIsArr = isArray(object),\n      othIsArr = isArray(other),\n      objTag = objIsArr ? arrayTag : getTag(object),\n      othTag = othIsArr ? arrayTag : getTag(other);\n\n  objTag = objTag == argsTag ? objectTag : objTag;\n  othTag = othTag == argsTag ? objectTag : othTag;\n\n  var objIsObj = objTag == objectTag,\n      othIsObj = othTag == objectTag,\n      isSameTag = objTag == othTag;\n\n  if (isSameTag && isBuffer(object)) {\n    if (!isBuffer(other)) {\n      return false;\n    }\n    objIsArr = true;\n    objIsObj = false;\n  }\n  if (isSameTag && !objIsObj) {\n    stack || (stack = new Stack);\n    return (objIsArr || isTypedArray(object))\n      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n  }\n  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n    if (objIsWrapped || othIsWrapped) {\n      var objUnwrapped = objIsWrapped ? object.value() : object,\n          othUnwrapped = othIsWrapped ? other.value() : other;\n\n      stack || (stack = new Stack);\n      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n    }\n  }\n  if (!isSameTag) {\n    return false;\n  }\n  stack || (stack = new Stack);\n  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\nmodule.exports = baseIsEqualDeep;\n","/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n  this.__data__.set(value, HASH_UNDEFINED);\n  return this;\n}\n\nmodule.exports = setCacheAdd;\n","\"use strict\";\n\nconst VOID_0 = t => t.unaryExpression(\"void\", t.numericLiteral(0), true);\n\nconst evaluate = require(\"babel-helper-evaluate-path\"); // Types as Symbols - for comparing types\n\n\nconst types = {}; // This is a test key which is used to avoid Object.keys check\n// Object.keys() check is really expensive\n// https://gist.github.com/vigneshshanmugam/c766550ecd02292dcdfbf0bf013b9d3d\n\nconst testKey = \"Expression\";\n\nconst typeSymbols = t => {\n  // don't recompute\n  if (types[testKey] !== undefined) {\n    return types;\n  }\n\n  t.TYPES.forEach(type => {\n    types[type] = Symbol.for(type);\n  });\n  return types;\n};\n\nconst isNodeOfType = (t, node, typeSymbol) => typeof typeSymbol !== \"symbol\" ? false : t[\"is\" + Symbol.keyFor(typeSymbol)](node);\n\nconst isPatternMatchesPath = t => function _isPatternMatchesPath(patternValue, inputPath) {\n  if (Array.isArray(patternValue)) {\n    for (let i = 0; i < patternValue.length; i++) {\n      if (_isPatternMatchesPath(patternValue[i], inputPath)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  if (typeof patternValue === \"function\") {\n    return patternValue(inputPath);\n  }\n\n  if (isNodeOfType(t, inputPath.node, patternValue)) return true;\n  const evalResult = evaluate(inputPath);\n  if (!evalResult.confident || !inputPath.isPure()) return false;\n  return evalResult.value === patternValue;\n};\n\nmodule.exports = {\n  VOID_0,\n  // Types as Symbols\n  typeSymbols,\n  // This is required for resolving type aliases\n  isNodeOfType,\n  isPatternMatchesPath\n};","var baseHasIn = require('./_baseHasIn'),\n    hasPath = require('./_hasPath');\n\n/**\n * Checks if `path` is a direct or inherited property of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.hasIn(object, 'a');\n * // => true\n *\n * _.hasIn(object, 'a.b');\n * // => true\n *\n * _.hasIn(object, ['a', 'b']);\n * // => true\n *\n * _.hasIn(object, 'b');\n * // => false\n */\nfunction hasIn(object, path) {\n  return object != null && hasPath(object, path, baseHasIn);\n}\n\nmodule.exports = hasIn;\n","\"use strict\";\n\nmodule.exports = function ({\n  types: t\n}) {\n  return {\n    name: \"transform-member-expression-literals\",\n    visitor: {\n      // foo['bar'] -> foo.bar\n      MemberExpression: {\n        exit({\n          node\n        }) {\n          const prop = node.property;\n\n          if (!node.computed || !t.isStringLiteral(prop)) {\n            return;\n          }\n\n          if (prop.value.match(/^\\d+$/)) {\n            const newProp = parseInt(prop.value, 10);\n\n            if (newProp.toString() === prop.value) {\n              node.property = t.numericLiteral(newProp);\n              node.computed = false;\n            }\n          } else if (t.isValidIdentifier(prop.value)) {\n            node.property = t.identifier(prop.value);\n            node.computed = false;\n          }\n        }\n\n      }\n    }\n  };\n};","\"use strict\";\n\nconst Collapser = require(\"./collapser\");\n\nclass ArrayCollapser extends Collapser {\n  isInitTypeValid(init) {\n    return init.isArrayExpression();\n  }\n\n  isExpressionTypeValid(expr) {\n    return expr.isCallExpression();\n  }\n\n  getExpressionChecker(objName, checkReference) {\n    return expr => {\n      // checks expr is of form:\n      // foo.push(rval1, ...nrvals)\n      const callee = expr.get(\"callee\");\n\n      if (!callee.isMemberExpression()) {\n        return false;\n      }\n\n      const obj = callee.get(\"object\"),\n            prop = callee.get(\"property\");\n\n      if (!obj.isIdentifier() || obj.node.name !== objName || !prop.isIdentifier() || prop.node.name !== \"push\") {\n        return false;\n      }\n\n      const args = expr.get(\"arguments\");\n\n      if (args.some(checkReference)) {\n        return false;\n      }\n\n      return true;\n    };\n  }\n\n  extractAssignment(expr) {\n    return expr.node.arguments;\n  }\n\n  addSuccessfully(t, args, init) {\n    args.map(a => init.elements.push(a));\n    return true;\n  }\n\n}\n\nmodule.exports = ArrayCollapser;","/*\n  Copyright (C) 2013 Yusuke Suzuki <utatane.tea@gmail.com>\n\n  Redistribution and use in source and binary forms, with or without\n  modification, are permitted provided that the following conditions are met:\n\n    * Redistributions of source code must retain the above copyright\n      notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above copyright\n      notice, this list of conditions and the following disclaimer in the\n      documentation and/or other materials provided with the distribution.\n\n  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY\n  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n(function () {\n    'use strict';\n\n    var code = require('./code');\n\n    function isStrictModeReservedWordES6(id) {\n        switch (id) {\n        case 'implements':\n        case 'interface':\n        case 'package':\n        case 'private':\n        case 'protected':\n        case 'public':\n        case 'static':\n        case 'let':\n            return true;\n        default:\n            return false;\n        }\n    }\n\n    function isKeywordES5(id, strict) {\n        // yield should not be treated as keyword under non-strict mode.\n        if (!strict && id === 'yield') {\n            return false;\n        }\n        return isKeywordES6(id, strict);\n    }\n\n    function isKeywordES6(id, strict) {\n        if (strict && isStrictModeReservedWordES6(id)) {\n            return true;\n        }\n\n        switch (id.length) {\n        case 2:\n            return (id === 'if') || (id === 'in') || (id === 'do');\n        case 3:\n            return (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try');\n        case 4:\n            return (id === 'this') || (id === 'else') || (id === 'case') ||\n                (id === 'void') || (id === 'with') || (id === 'enum');\n        case 5:\n            return (id === 'while') || (id === 'break') || (id === 'catch') ||\n                (id === 'throw') || (id === 'const') || (id === 'yield') ||\n                (id === 'class') || (id === 'super');\n        case 6:\n            return (id === 'return') || (id === 'typeof') || (id === 'delete') ||\n                (id === 'switch') || (id === 'export') || (id === 'import');\n        case 7:\n            return (id === 'default') || (id === 'finally') || (id === 'extends');\n        case 8:\n            return (id === 'function') || (id === 'continue') || (id === 'debugger');\n        case 10:\n            return (id === 'instanceof');\n        default:\n            return false;\n        }\n    }\n\n    function isReservedWordES5(id, strict) {\n        return id === 'null' || id === 'true' || id === 'false' || isKeywordES5(id, strict);\n    }\n\n    function isReservedWordES6(id, strict) {\n        return id === 'null' || id === 'true' || id === 'false' || isKeywordES6(id, strict);\n    }\n\n    function isRestrictedWord(id) {\n        return id === 'eval' || id === 'arguments';\n    }\n\n    function isIdentifierNameES5(id) {\n        var i, iz, ch;\n\n        if (id.length === 0) { return false; }\n\n        ch = id.charCodeAt(0);\n        if (!code.isIdentifierStartES5(ch)) {\n            return false;\n        }\n\n        for (i = 1, iz = id.length; i < iz; ++i) {\n            ch = id.charCodeAt(i);\n            if (!code.isIdentifierPartES5(ch)) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    function decodeUtf16(lead, trail) {\n        return (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;\n    }\n\n    function isIdentifierNameES6(id) {\n        var i, iz, ch, lowCh, check;\n\n        if (id.length === 0) { return false; }\n\n        check = code.isIdentifierStartES6;\n        for (i = 0, iz = id.length; i < iz; ++i) {\n            ch = id.charCodeAt(i);\n            if (0xD800 <= ch && ch <= 0xDBFF) {\n                ++i;\n                if (i >= iz) { return false; }\n                lowCh = id.charCodeAt(i);\n                if (!(0xDC00 <= lowCh && lowCh <= 0xDFFF)) {\n                    return false;\n                }\n                ch = decodeUtf16(ch, lowCh);\n            }\n            if (!check(ch)) {\n                return false;\n            }\n            check = code.isIdentifierPartES6;\n        }\n        return true;\n    }\n\n    function isIdentifierES5(id, strict) {\n        return isIdentifierNameES5(id) && !isReservedWordES5(id, strict);\n    }\n\n    function isIdentifierES6(id, strict) {\n        return isIdentifierNameES6(id) && !isReservedWordES6(id, strict);\n    }\n\n    module.exports = {\n        isKeywordES5: isKeywordES5,\n        isKeywordES6: isKeywordES6,\n        isReservedWordES5: isReservedWordES5,\n        isReservedWordES6: isReservedWordES6,\n        isRestrictedWord: isRestrictedWord,\n        isIdentifierNameES5: isIdentifierNameES5,\n        isIdentifierNameES6: isIdentifierNameES6,\n        isIdentifierES5: isIdentifierES5,\n        isIdentifierES6: isIdentifierES6\n    };\n}());\n/* vim: set sw=4 ts=4 et tw=80 : */\n","var isArrayLike = require('./isArrayLike');\n\n/**\n * Creates a `baseEach` or `baseEachRight` function.\n *\n * @private\n * @param {Function} eachFunc The function to iterate over a collection.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseEach(eachFunc, fromRight) {\n  return function(collection, iteratee) {\n    if (collection == null) {\n      return collection;\n    }\n    if (!isArrayLike(collection)) {\n      return eachFunc(collection, iteratee);\n    }\n    var length = collection.length,\n        index = fromRight ? length : -1,\n        iterable = Object(collection);\n\n    while ((fromRight ? index-- : ++index < length)) {\n      if (iteratee(iterable[index], index, iterable) === false) {\n        break;\n      }\n    }\n    return collection;\n  };\n}\n\nmodule.exports = createBaseEach;\n","var Stack = require('./_Stack'),\n    baseIsEqual = require('./_baseIsEqual');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * The base implementation of `_.isMatch` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property values to match.\n * @param {Array} matchData The property names, values, and compare flags to match.\n * @param {Function} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n */\nfunction baseIsMatch(object, source, matchData, customizer) {\n  var index = matchData.length,\n      length = index,\n      noCustomizer = !customizer;\n\n  if (object == null) {\n    return !length;\n  }\n  object = Object(object);\n  while (index--) {\n    var data = matchData[index];\n    if ((noCustomizer && data[2])\n          ? data[1] !== object[data[0]]\n          : !(data[0] in object)\n        ) {\n      return false;\n    }\n  }\n  while (++index < length) {\n    data = matchData[index];\n    var key = data[0],\n        objValue = object[key],\n        srcValue = data[1];\n\n    if (noCustomizer && data[2]) {\n      if (objValue === undefined && !(key in object)) {\n        return false;\n      }\n    } else {\n      var stack = new Stack;\n      if (customizer) {\n        var result = customizer(objValue, srcValue, key, object, source, stack);\n      }\n      if (!(result === undefined\n            ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n            : result\n          )) {\n        return false;\n      }\n    }\n  }\n  return true;\n}\n\nmodule.exports = baseIsMatch;\n","\"use strict\";\n\nconst Collapser = require(\"./collapser\");\n\nclass SetCollapser extends Collapser {\n  isInitTypeValid(init) {\n    return init.isNewExpression() && init.get(\"callee\").isIdentifier() && init.node.callee.name === \"Set\" && ( // other iterables might not be append-able\n    init.node.arguments.length === 0 || init.node.arguments.length === 1 && init.get(\"arguments\")[0].isArrayExpression());\n  }\n\n  isExpressionTypeValid(expr) {\n    return expr.isCallExpression();\n  }\n\n  getExpressionChecker(objName, checkReference) {\n    return expr => {\n      // checks expr is of form:\n      // foo.add(rval)\n      const callee = expr.get(\"callee\");\n\n      if (!callee.isMemberExpression()) {\n        return false;\n      }\n\n      const obj = callee.get(\"object\"),\n            prop = callee.get(\"property\");\n\n      if (!obj.isIdentifier() || obj.node.name !== objName || !prop.isIdentifier() || prop.node.name !== \"add\") {\n        return false;\n      }\n\n      const args = expr.get(\"arguments\");\n\n      if (args.length !== 1) {\n        return false;\n      }\n\n      if (checkReference(args[0])) {\n        return false;\n      }\n\n      return true;\n    };\n  }\n\n  extractAssignment(expr) {\n    return expr.node.arguments[0];\n  }\n\n  addSuccessfully(t, arg, init) {\n    if (init.arguments.length === 0) {\n      init.arguments.push(t.arrayExpression());\n    }\n\n    init.arguments[0].elements.push(arg);\n    return true;\n  }\n\n}\n\nmodule.exports = SetCollapser;","var baseGet = require('./_baseGet');\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is\n * `undefined`, the `defaultValue` is returned in its place.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.get(object, 'a[0].b.c');\n * // => 3\n *\n * _.get(object, ['a', '0', 'b', 'c']);\n * // => 3\n *\n * _.get(object, 'a.b.c', 'default');\n * // => 'default'\n */\nfunction get(object, path, defaultValue) {\n  var result = object == null ? undefined : baseGet(object, path);\n  return result === undefined ? defaultValue : result;\n}\n\nmodule.exports = get;\n","\"use strict\";\n\nmodule.exports = function () {\n  return {\n    name: \"minify-numeric-literals\",\n    visitor: {\n      NumericLiteral(path) {\n        if (!path.node.extra) return;\n        const normal = path.node.value.toString().replace(/^0\\./, \".\");\n        let exponential = path.node.value.toExponential().replace(/\\+/g, \"\");\n\n        if (exponential.indexOf(\".\") >= 0 && exponential.indexOf(\"e\") >= 0) {\n          const lastChar = exponential.substr(exponential.lastIndexOf(\"e\") + 1);\n          const dotIndex = exponential.lastIndexOf(\".\") + 1;\n          const subLength = exponential.substr(dotIndex, exponential.lastIndexOf(\"e\") - dotIndex).length;\n          exponential = (exponential.substr(0, exponential.lastIndexOf(\"e\") + 1) + (lastChar - subLength)).replace(\".\", \"\").replace(/e0/, \"\");\n        }\n\n        const replacement = normal.length > exponential.length ? exponential : normal;\n\n        if (path.node.extra.raw.length > replacement.length) {\n          path.node.extra.raw = replacement;\n        }\n      }\n\n    }\n  };\n};","var SetCache = require('./_SetCache'),\n    arraySome = require('./_arraySome'),\n    cacheHas = require('./_cacheHas');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      arrLength = array.length,\n      othLength = other.length;\n\n  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n    return false;\n  }\n  // Check that cyclic values are equal.\n  var arrStacked = stack.get(array);\n  var othStacked = stack.get(other);\n  if (arrStacked && othStacked) {\n    return arrStacked == other && othStacked == array;\n  }\n  var index = -1,\n      result = true,\n      seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n  stack.set(array, other);\n  stack.set(other, array);\n\n  // Ignore non-index properties.\n  while (++index < arrLength) {\n    var arrValue = array[index],\n        othValue = other[index];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, arrValue, index, other, array, stack)\n        : customizer(arrValue, othValue, index, array, other, stack);\n    }\n    if (compared !== undefined) {\n      if (compared) {\n        continue;\n      }\n      result = false;\n      break;\n    }\n    // Recursively compare arrays (susceptible to call stack limits).\n    if (seen) {\n      if (!arraySome(other, function(othValue, othIndex) {\n            if (!cacheHas(seen, othIndex) &&\n                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n              return seen.push(othIndex);\n            }\n          })) {\n        result = false;\n        break;\n      }\n    } else if (!(\n          arrValue === othValue ||\n            equalFunc(arrValue, othValue, bitmask, customizer, stack)\n        )) {\n      result = false;\n      break;\n    }\n  }\n  stack['delete'](array);\n  stack['delete'](other);\n  return result;\n}\n\nmodule.exports = equalArrays;\n","\"use strict\";\n\nmodule.exports = function ({\n  types: t\n}) {\n  const INFINITY = t.binaryExpression(\"/\", t.numericLiteral(1), t.numericLiteral(0));\n  return {\n    name: \"minify-infinity\",\n    visitor: {\n      // Infinity -> 1 / 0\n      Identifier(path) {\n        if (path.node.name !== \"Infinity\") {\n          return;\n        } // It's a referenced identifier\n\n\n        if (path.scope.getBinding(\"Infinity\")) {\n          return;\n        }\n\n        if (path.parentPath.isObjectProperty({\n          key: path.node\n        })) {\n          return;\n        }\n\n        if (path.parentPath.isMemberExpression()) {\n          return;\n        }\n\n        const bindingIds = path.parentPath.getBindingIdentifierPaths();\n\n        if (bindingIds[\"Infinity\"] === path && // ObjectProperty is common for ObjectExpression and ObjectPattern and only\n        // one of them is a Binding, the other is simply a reference\n        !path.parentPath.parentPath.isObjectExpression()) {\n          return;\n        }\n\n        path.replaceWith(INFINITY);\n      }\n\n    }\n  };\n};","\"use strict\";\n\nmodule.exports = isLabelIdentifier;\n\nfunction isLabelIdentifier(path) {\n  const node = path.node;\n  return path.parentPath.isLabeledStatement({\n    label: node\n  }) || path.parentPath.isBreakStatement({\n    label: node\n  }) || path.parentPath.isContinueStatement({\n    label: node\n  });\n}","/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\nmodule.exports = setToArray;\n","\"use strict\";\n\nfunction replaceArray(t, path) {\n  const node = path.node; // arguments is taken :(\n\n  const constructorArgs = path.get(\"arguments\");\n\n  if (t.isIdentifier(node.callee, {\n    name: \"Array\"\n  }) && !path.scope.getBinding(\"Array\")) {\n    if (constructorArgs.length === 0) {\n      // Array() -> []\n      path.replaceWith(t.arrayExpression([]));\n    } else if (constructorArgs.length === 1) {\n      const arg = constructorArgs[0];\n      const result = arg.evaluate();\n\n      if (result.confident) {\n        if (typeof result.value === \"number\") {\n          if (result.value >= 0 && result.value <= 6 && result.value % 1 === 0) {\n            // \"Array(7)\" is shorter than \"[,,,,,,,]\"\n            path.replaceWith(t.arrayExpression(Array(result.value).fill(null)));\n          } else {\n            dropNewIfPresent();\n          }\n        } else {\n          // Array(\"Asdf\"), Array(true), Array(false)\n          path.replaceWith(t.arrayExpression([t.valueToNode(result.value)]));\n        }\n      } else {\n        const transformables = [\"ArrayExpression\", \"ObjectExpression\", \"FunctionExpression\", \"ArrowFunctionExpression\", \"ClassExpression\"];\n\n        if (transformables.indexOf(arg.node.type) !== -1) {\n          // Array([]), Array({})\n          // Array(()=>{}), Array(class{}), Array(function(){})\n          path.replaceWith(t.arrayExpression([arg.node]));\n        } else {\n          // Array(x); Array(a.b);\n          dropNewIfPresent();\n        }\n      }\n    } else {\n      // Array(2,3), Array(a,b) => [2,3], [a,b]\n      path.replaceWith(t.arrayExpression(node.arguments));\n    }\n\n    return true;\n  }\n\n  function dropNewIfPresent() {\n    if (path.isNewExpression()) {\n      path.replaceWith(t.callExpression(node.callee, node.arguments));\n    }\n  }\n}\n\nfunction replaceObject(t, path) {\n  const node = path.node;\n\n  if (t.isIdentifier(node.callee, {\n    name: \"Object\"\n  }) && !path.scope.getBinding(\"Object\")) {\n    const isVoid0 = require(\"babel-helper-is-void-0\")(t);\n\n    const arg = node.arguments[0];\n    const binding = arg && t.isIdentifier(arg) && path.scope.getBinding(arg.name); // Object() -> {}\n\n    if (node.arguments.length === 0) {\n      path.replaceWith(t.objectExpression([])); // Object([]) -> []\n    } else if (arg.type === \"ArrayExpression\" || t.isFunctionExpression(arg)) {\n      path.replaceWith(arg); // Object(null) -> {}\n    } else if (isVoid0(arg) || arg.name === \"undefined\" || arg.type === \"NullLiteral\" || arg.type === \"ObjectExpression\" && arg.properties.length === 0) {\n      path.replaceWith(t.objectExpression([])); // Object(localFn) -> localFn\n    } else if (binding && binding.path.isFunction()) {\n      path.replaceWith(arg); // Object({a:b}) -> {a:b}\n    } else if (arg.type === \"ObjectExpression\") {\n      path.replaceWith(arg); // new Object(a) -> Object(a)\n    } else if (node.type === \"NewExpression\") {\n      path.replaceWith(t.callExpression(node.callee, node.arguments));\n    }\n\n    return true;\n  }\n}\n\nfunction defaults({\n  boolean = true,\n  number = true,\n  string = true,\n  array = true,\n  object = true\n} = {}) {\n  return {\n    boolean,\n    number,\n    string,\n    array,\n    object\n  };\n}\n\nmodule.exports = function ({\n  types: t\n}) {\n  return {\n    name: \"minify-type-constructors\",\n    visitor: {\n      CallExpression(path) {\n        const node = path.node;\n        const opts = defaults(this.opts); // Boolean(foo) -> !!foo\n\n        if (opts.boolean && t.isIdentifier(node.callee, {\n          name: \"Boolean\"\n        }) && node.arguments.length === 1 && !path.scope.getBinding(\"Boolean\")) {\n          path.replaceWith(t.unaryExpression(\"!\", t.unaryExpression(\"!\", node.arguments[0], true), true));\n          return;\n        } // Number(foo) -> +foo\n\n\n        if (opts.number && t.isIdentifier(node.callee, {\n          name: \"Number\"\n        }) && node.arguments.length === 1 && !path.scope.getBinding(\"Number\")) {\n          path.replaceWith(t.unaryExpression(\"+\", node.arguments[0], true));\n          return;\n        } // String(foo) -> foo + ''\n\n\n        if (opts.string && t.isIdentifier(node.callee, {\n          name: \"String\"\n        }) && node.arguments.length === 1 && !path.scope.getBinding(\"String\")) {\n          path.replaceWith(t.binaryExpression(\"+\", node.arguments[0], t.stringLiteral(\"\")));\n          return;\n        } // Array() -> []\n\n\n        if (opts.array && replaceArray(t, path)) {\n          return;\n        } // Object() -> {}\n\n\n        if (opts.object && replaceObject(t, path)) {\n          return;\n        }\n      },\n\n      NewExpression(path) {\n        const opts = defaults(this.opts); // new Array() -> []\n\n        if (opts.array && replaceArray(t, path)) {\n          return;\n        } // new Object() -> {}\n\n\n        if (opts.object && replaceObject(t, path)) {\n          return;\n        }\n      }\n\n    }\n  };\n};","\"use strict\";\n\nconst NotImplementedError = Error(\"NotImplementedError\");\n\nclass Collapser {\n  isInitTypeValid() {\n    throw NotImplementedError;\n  }\n\n  isExpressionTypeValid() {\n    throw NotImplementedError;\n  }\n\n  getExpressionChecker() {\n    throw NotImplementedError;\n  }\n\n  extractAssignment() {\n    throw NotImplementedError;\n  }\n\n  addSuccessfully() {\n    throw NotImplementedError;\n  }\n\n  isSizeSmaller() {\n    return true;\n  }\n\n}\n\nmodule.exports = Collapser;","\"use strict\";\n\nconst FALLBACK_HANDLER = Symbol(\"fallback handler\");\n\nmodule.exports = ({\n  types: t\n}) => {\n  const undef = t.unaryExpression(\"void\", t.numericLiteral(0));\n\n  function isUndef(ob) {\n    return ob === undefined || t.isIdentifier(ob, {\n      name: \"undefined\"\n    }) || t.isUnaryExpression(ob, {\n      operator: \"void\"\n    });\n  }\n\n  function defaultZero(cb) {\n    return function (i = t.numericLiteral(0), ...args) {\n      if (t.isNumericLiteral(i)) {\n        return cb.call(this.node, this.node, i.value, ...args);\n      }\n    };\n  }\n\n  function hasSpread(node) {\n    return node.elements.some(el => t.isSpreadElement(el));\n  }\n\n  return {\n    ArrayExpression: {\n      canReplace() {\n        return !hasSpread(this.node);\n      },\n\n      members: {\n        length() {\n          if (hasSpread(this.node)) {\n            return;\n          }\n\n          return t.numericLiteral(this.node.elements.length);\n        },\n\n        [FALLBACK_HANDLER](i) {\n          if (hasSpread(this.node)) {\n            return;\n          }\n\n          if (typeof i === \"number\" || i.match(/^\\d+$/)) {\n            return this.node.elements[i] || undef;\n          }\n        }\n\n      },\n      calls: {\n        join(sep = t.stringLiteral(\",\")) {\n          if (!t.isStringLiteral(sep)) return;\n          let bad = false;\n          const str = this.get(\"elements\").map(el => {\n            const evaled = el.evaluate();\n\n            if (!evaled.confident) {\n              bad = true;\n              return;\n            }\n\n            return evaled.value;\n          }).join(sep.value);\n          return bad ? void 0 : t.stringLiteral(str);\n        },\n\n        push(...args) {\n          return t.numericLiteral(this.node.elements.length + args.length);\n        },\n\n        shift() {\n          if (this.node.elements.length === 0) {\n            return undef;\n          }\n\n          return t.numericLiteral(this.node.elements.length - 1);\n        },\n\n        slice(start = t.numericLiteral(0), end) {\n          if (!t.isNumericLiteral(start) || end && !t.isNumericLiteral(end)) {\n            return;\n          }\n\n          return t.arrayExpression(this.node.elements.slice(start.value, end && end.value));\n        },\n\n        pop() {\n          return this.node.elements[this.node.elements.length - 1] || undef;\n        },\n\n        reverse() {\n          return t.arrayExpression(this.node.elements.reverse());\n        },\n\n        splice(start, end, ...args) {\n          if (!t.isNumericLiteral(start) || end && !t.isNumericLiteral(end)) {\n            return;\n          }\n\n          if (end) {\n            args.unshift(end.value);\n          }\n\n          return t.arrayExpression(this.node.elements.slice().splice(start.value, ...args));\n        }\n\n      }\n    },\n    StringLiteral: {\n      members: {\n        length() {\n          return t.numericLiteral(this.node.value.length);\n        },\n\n        [FALLBACK_HANDLER](i) {\n          if (typeof i === \"number\" || i.match(/^\\d+$/)) {\n            const ch = this.node.value[i];\n            return ch ? t.stringLiteral(ch) : undef;\n          }\n        }\n\n      },\n      calls: {\n        split(sep = undef) {\n          let realSep = null;\n\n          if (t.isStringLiteral(sep)) {\n            realSep = sep.value;\n          }\n\n          if (isUndef(sep)) {\n            realSep = sep;\n          }\n\n          if (realSep !== null) {\n            return t.arrayExpression(this.node.value.split(realSep).map(str => t.stringLiteral(str)));\n          }\n        },\n\n        charAt: defaultZero(({\n          value\n        }, i) => t.stringLiteral(value.charAt(i))),\n        charCodeAt: defaultZero(({\n          value\n        }, i) => t.numericLiteral(value.charCodeAt(i))),\n        codePointAt: defaultZero(({\n          value\n        }, i) => t.numericLiteral(value.codePointAt(i)))\n      }\n    }\n  };\n};\n\nmodule.exports.FALLBACK_HANDLER = FALLBACK_HANDLER;","\"use strict\";\n\nmodule.exports = function (t) {\n  return function toMultipleSequenceExpressions(statements) {\n    const retStatements = [];\n    let bailed;\n\n    do {\n      const res = convert(statements);\n      bailed = res.bailed;\n      const seq = res.seq,\n            bailedAtIndex = res.bailedAtIndex;\n\n      if (seq) {\n        retStatements.push(t.expressionStatement(seq));\n      }\n\n      if (bailed && statements[bailedAtIndex]) {\n        retStatements.push(statements[bailedAtIndex]);\n      }\n\n      if (bailed) {\n        statements = statements.slice(bailedAtIndex + 1);\n\n        if (!statements.length) {\n          bailed = false;\n        }\n      }\n    } while (bailed);\n\n    return retStatements;\n\n    function convert(nodes) {\n      const exprs = [];\n      const comments = [];\n\n      for (let i = 0; i < nodes.length; i++) {\n        const bail = () => {\n          let seq;\n\n          if (exprs.length === 1) {\n            seq = exprs[0];\n          } else if (exprs.length) {\n            seq = t.sequenceExpression(exprs);\n          }\n\n          return {\n            seq,\n            bailed: true,\n            bailedAtIndex: i\n          };\n        };\n\n        const node = nodes[i];\n\n        if (t.isExpression(node)) {\n          exprs.push(node);\n        } else if (t.isExpressionStatement(node)) {\n          if (node.leadingComments) {\n            comments.push(...node.leadingComments);\n          }\n\n          if (node.expression) exprs.push(node.expression);\n        } else if (t.isIfStatement(node)) {\n          let consequent;\n\n          if (node.consequent) {\n            const res = convert([node.consequent]);\n\n            if (res.bailed) {\n              return bail();\n            }\n\n            consequent = res.seq;\n          }\n\n          let alternate;\n\n          if (node.alternate) {\n            const res = convert([node.alternate]);\n\n            if (res.bailed) {\n              return bail();\n            }\n\n            alternate = res.seq;\n          }\n\n          if (!alternate && !consequent) {\n            exprs.push(node.test);\n          } else if (!alternate) {\n            exprs.push(t.logicalExpression(\"&&\", node.test, consequent));\n          } else if (!consequent) {\n            exprs.push(t.logicalExpression(\"||\", node.test, alternate));\n          } else {\n            exprs.push(t.conditionalExpression(node.test, consequent, alternate));\n          }\n        } else if (t.isBlockStatement(node)) {\n          const res = convert(node.body);\n\n          if (res.bailed) {\n            return bail();\n          }\n\n          if (res.seq) {\n            exprs.push(res.seq);\n          }\n        } else {\n          return bail();\n        }\n      }\n\n      let seq;\n\n      if (exprs.length === 1) {\n        seq = exprs[0];\n      } else if (exprs.length) {\n        seq = t.sequenceExpression(exprs);\n      }\n      /**\n       * collect all the comment ast nodes that are before expression\n       * statments and add it to the new generated node\n       */\n\n\n      if (seq) {\n        seq.leadingComments = comments;\n      }\n      /* eslint-disable no-self-assign */\n\n\n      seq = seq;\n      return {\n        seq\n      };\n    }\n  };\n};","\"use strict\";\n\nmodule.exports = function ({\n  types: t\n}) {\n  const TRUE = t.unaryExpression(\"!\", t.numericLiteral(0), true);\n  const FALSE = t.unaryExpression(\"!\", t.numericLiteral(1), true);\n  return {\n    name: \"transform-minify-booleans\",\n    visitor: {\n      // shorten booleans to a negation\n      // true -> !0\n      // false -> !1\n      BooleanLiteral(path) {\n        path.replaceWith(path.node.value ? TRUE : FALSE);\n      }\n\n    }\n  };\n};","var getAllKeys = require('./_getAllKeys');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      objProps = getAllKeys(object),\n      objLength = objProps.length,\n      othProps = getAllKeys(other),\n      othLength = othProps.length;\n\n  if (objLength != othLength && !isPartial) {\n    return false;\n  }\n  var index = objLength;\n  while (index--) {\n    var key = objProps[index];\n    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n      return false;\n    }\n  }\n  // Check that cyclic values are equal.\n  var objStacked = stack.get(object);\n  var othStacked = stack.get(other);\n  if (objStacked && othStacked) {\n    return objStacked == other && othStacked == object;\n  }\n  var result = true;\n  stack.set(object, other);\n  stack.set(other, object);\n\n  var skipCtor = isPartial;\n  while (++index < objLength) {\n    key = objProps[index];\n    var objValue = object[key],\n        othValue = other[key];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, objValue, key, other, object, stack)\n        : customizer(objValue, othValue, key, object, other, stack);\n    }\n    // Recursively compare objects (susceptible to call stack limits).\n    if (!(compared === undefined\n          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n          : compared\n        )) {\n      result = false;\n      break;\n    }\n    skipCtor || (skipCtor = key == 'constructor');\n  }\n  if (result && !skipCtor) {\n    var objCtor = object.constructor,\n        othCtor = other.constructor;\n\n    // Non `Object` object instances with different constructors are not equal.\n    if (objCtor != othCtor &&\n        ('constructor' in object && 'constructor' in other) &&\n        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n          typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n      result = false;\n    }\n  }\n  stack['delete'](object);\n  stack['delete'](other);\n  return result;\n}\n\nmodule.exports = equalObjects;\n","var baseMatches = require('./_baseMatches'),\n    baseMatchesProperty = require('./_baseMatchesProperty'),\n    identity = require('./identity'),\n    isArray = require('./isArray'),\n    property = require('./property');\n\n/**\n * The base implementation of `_.iteratee`.\n *\n * @private\n * @param {*} [value=_.identity] The value to convert to an iteratee.\n * @returns {Function} Returns the iteratee.\n */\nfunction baseIteratee(value) {\n  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n  if (typeof value == 'function') {\n    return value;\n  }\n  if (value == null) {\n    return identity;\n  }\n  if (typeof value == 'object') {\n    return isArray(value)\n      ? baseMatchesProperty(value[0], value[1])\n      : baseMatches(value);\n  }\n  return property(value);\n}\n\nmodule.exports = baseIteratee;\n","var baseIsEqualDeep = require('./_baseIsEqualDeep'),\n    isObjectLike = require('./isObjectLike');\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Unordered comparison\n *  2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n  if (value === other) {\n    return true;\n  }\n  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n    return value !== value && other !== other;\n  }\n  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\nmodule.exports = baseIsEqual;\n","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); }\n\nfunction _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nmodule.exports = function evaluate(path, {\n  tdz = false\n} = {}) {\n  if (!tdz && !path.isReferencedIdentifier()) {\n    return baseEvaluate(path);\n  }\n\n  if (path.isReferencedIdentifier()) {\n    return evaluateIdentifier(path);\n  }\n\n  const state = {\n    confident: true\n  }; // prepare\n\n  path.traverse({\n    Scope(scopePath) {\n      scopePath.skip();\n    },\n\n    ReferencedIdentifier(idPath) {\n      const binding = idPath.scope.getBinding(idPath.node.name); // don't deopt globals\n      // let babel take care of it\n\n      if (!binding) return;\n      const evalResult = evaluateIdentifier(idPath);\n\n      if (!evalResult.confident) {\n        state.confident = evalResult.confident;\n        state.deoptPath = evalResult.deoptPath;\n      }\n    }\n\n  });\n\n  if (!state.confident) {\n    return state;\n  }\n\n  return baseEvaluate(path);\n};\n\nfunction baseEvaluate(path) {\n  try {\n    return path.evaluate();\n  } catch (e) {\n    return {\n      confident: false,\n      error: e\n    };\n  }\n} // Original Source:\n// https://github.com/babel/babel/blob/master/packages/babel-traverse/src/path/evaluation.js\n// modified for Babel-minify use\n\n\nfunction evaluateIdentifier(path) {\n  if (!path.isReferencedIdentifier()) {\n    throw new Error(`Expected ReferencedIdentifier. Got ${path.type}`);\n  }\n\n  const node = path.node;\n  const binding = path.scope.getBinding(node.name);\n\n  if (!binding) {\n    const name = node.name;\n\n    if (!name) {\n      return deopt(path);\n    }\n\n    switch (name) {\n      case \"undefined\":\n        return {\n          confident: true,\n          value: undefined\n        };\n\n      case \"NaN\":\n        return {\n          confident: true,\n          value: NaN\n        };\n\n      case \"Infinity\":\n        return {\n          confident: true,\n          value: Infinity\n        };\n\n      default:\n        return deopt(path);\n    }\n  }\n\n  if (binding.constantViolations.length > 0) {\n    return deopt(binding.path);\n  } // referenced in a different scope - deopt\n\n\n  if (shouldDeoptBasedOnScope(binding, path)) {\n    return deopt(path);\n  } // let/var/const referenced before init\n  // or \"var\" referenced in an outer scope\n\n\n  const flowEvalResult = evaluateBasedOnControlFlow(binding, path);\n\n  if (flowEvalResult.confident) {\n    return flowEvalResult;\n  }\n\n  if (flowEvalResult.shouldDeopt) {\n    return deopt(path);\n  }\n\n  return path.evaluate();\n} // check if referenced in a different fn scope\n// we can't determine if this function is called sync or async\n// if the binding is in program scope\n// all it's references inside a different function should be deopted\n\n\nfunction shouldDeoptBasedOnScope(binding, refPath) {\n  if (binding.scope.path.isProgram() && refPath.scope !== binding.scope) {\n    return true;\n  }\n\n  return false;\n}\n\nfunction evaluateBasedOnControlFlow(binding, refPath) {\n  if (binding.kind === \"var\") {\n    // early-exit\n    const declaration = binding.path.parentPath;\n\n    if (declaration.parentPath) {\n      /**\n       * Handle when binding is created inside a parent block and\n       * the corresponding parent is removed by other plugins\n       * if (false) { var a } -> var a\n       */\n      if (declaration.parentPath.removed) {\n        return {\n          confident: true,\n          value: void 0\n        };\n      }\n\n      if (declaration.parentPath.isIfStatement() || declaration.parentPath.isLoop() || declaration.parentPath.isSwitchCase()) {\n        return {\n          shouldDeopt: true\n        };\n      }\n    }\n\n    const fnParent = (binding.path.scope.getFunctionParent() || binding.path.scope.getProgramParent()).path;\n    let blockParentPath = binding.path.scope.getBlockParent().path;\n    let blockParent = blockParentPath.node;\n\n    if (blockParentPath === fnParent && !fnParent.isProgram()) {\n      blockParent = blockParent.body;\n    } // detect Usage Outside Init Scope\n\n\n    const blockBody = blockParent.body;\n\n    if (Array.isArray(blockBody) && !blockBody.some(stmt => isAncestor(stmt, refPath))) {\n      return {\n        shouldDeopt: true\n      };\n    } // Detect usage before init\n\n\n    const stmts = fnParent.isProgram() ? fnParent.node.body : fnParent.node.body.body;\n    const compareResult = compareBindingAndReference({\n      binding,\n      refPath,\n      stmts\n    });\n\n    if (compareResult.reference && compareResult.binding) {\n      if (compareResult.reference.scope === \"current\" && compareResult.reference.idx < compareResult.binding.idx) {\n        return {\n          confident: true,\n          value: void 0\n        };\n      }\n    }\n  } else if (binding.kind === \"let\" || binding.kind === \"const\") {\n    // binding.path is the declarator\n    const declarator = binding.path;\n    const declaration = declarator.parentPath;\n\n    if (declaration.parentPath && (declaration.parentPath.isIfStatement() || declaration.parentPath.isLoop() || declaration.parentPath.isSwitchCase())) {\n      return {\n        shouldDeopt: true\n      };\n    }\n\n    const scopePath = declarator.scope.path;\n    let scopeNode = scopePath.node;\n\n    if (scopePath.isFunction() || scopePath.isCatchClause()) {\n      scopeNode = scopeNode.body;\n    } // Detect Usage before Init\n\n\n    let stmts = scopeNode.body;\n\n    if (!Array.isArray(stmts)) {\n      stmts = [stmts];\n    }\n\n    const compareResult = compareBindingAndReference({\n      binding,\n      refPath,\n      stmts\n    });\n\n    if (compareResult.reference && compareResult.binding) {\n      if (compareResult.reference.scope === \"current\" && compareResult.reference.idx < compareResult.binding.idx) {\n        throw new Error(`ReferenceError: Used ${refPath.node.name}: ` + `${binding.kind} binding before declaration`);\n      }\n\n      if (compareResult.reference.scope === \"other\") {\n        return {\n          shouldDeopt: true\n        };\n      }\n    }\n  }\n\n  return {\n    confident: false,\n    shouldDeopt: false\n  };\n}\n\nfunction compareBindingAndReference({\n  binding,\n  refPath,\n  stmts\n}) {\n  const state = {\n    binding: null,\n    reference: null\n  };\n  var _iteratorNormalCompletion = true;\n  var _didIteratorError = false;\n  var _iteratorError = undefined;\n\n  try {\n    for (var _iterator = stmts.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n      const _step$value = _slicedToArray(_step.value, 2),\n            idx = _step$value[0],\n            stmt = _step$value[1];\n\n      if (isAncestor(stmt, binding.path)) {\n        state.binding = {\n          idx\n        };\n      }\n\n      var _iteratorNormalCompletion2 = true;\n      var _didIteratorError2 = false;\n      var _iteratorError2 = undefined;\n\n      try {\n        for (var _iterator2 = binding.referencePaths[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n          const ref = _step2.value;\n\n          if (ref === refPath && isAncestor(stmt, ref)) {\n            state.reference = {\n              idx,\n              scope: binding.path.scope === ref.scope ? \"current\" : \"other\"\n            };\n            break;\n          }\n        }\n      } catch (err) {\n        _didIteratorError2 = true;\n        _iteratorError2 = err;\n      } finally {\n        try {\n          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {\n            _iterator2.return();\n          }\n        } finally {\n          if (_didIteratorError2) {\n            throw _iteratorError2;\n          }\n        }\n      }\n    }\n  } catch (err) {\n    _didIteratorError = true;\n    _iteratorError = err;\n  } finally {\n    try {\n      if (!_iteratorNormalCompletion && _iterator.return != null) {\n        _iterator.return();\n      }\n    } finally {\n      if (_didIteratorError) {\n        throw _iteratorError;\n      }\n    }\n  }\n\n  return state;\n}\n\nfunction deopt(deoptPath) {\n  return {\n    confident: false,\n    deoptPath\n  };\n}\n/**\n * is nodeParent an ancestor of path\n */\n\n\nfunction isAncestor(nodeParent, path) {\n  return !!path.findParent(parent => parent.node === nodeParent);\n}","/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n  return cache.has(key);\n}\n\nmodule.exports = cacheHas;\n","\"use strict\";\n\nconst h = require(\"./helpers\");\n\nconst PatternMatch = require(\"./pattern-match\");\n\nconst evaluate = require(\"babel-helper-evaluate-path\");\n\nmodule.exports = t => {\n  const OP_AND = input => input === \"&&\";\n\n  const OP_OR = input => input === \"||\";\n\n  function simplifyPatterns(path) {\n    // cache of evaluate(path)\n    const evaluateMemo = new Map();\n\n    const TRUTHY = input => {\n      // !NaN and !undefined are truthy\n      // separate check here as they are considered impure by babel\n      if (input.isUnaryExpression() && input.get(\"argument\").isIdentifier()) {\n        if (input.node.argument.name === \"NaN\" || input.node.argument.name === \"undefined\") {\n          return true;\n        }\n      }\n\n      const evalResult = evaluate(input);\n      evaluateMemo.set(input, evalResult);\n      return evalResult.confident && input.isPure() && evalResult.value;\n    };\n\n    const FALSY = input => {\n      // NaN and undefined are falsy\n      // separate check here as they are considered impure by babel\n      if (input.isIdentifier()) {\n        if (input.node.name === \"NaN\" || input.node.name === \"undefined\") {\n          return true;\n        }\n      }\n\n      const evalResult = evaluate(input);\n      evaluateMemo.set(input, evalResult);\n      return evalResult.confident && input.isPure() && !evalResult.value;\n    };\n\n    const _h$typeSymbols = h.typeSymbols(t),\n          EX = _h$typeSymbols.Expression; // Convention:\n    // [left, operator, right, handler(leftNode, rightNode)]\n\n\n    const matcher = new PatternMatch([[TRUTHY, OP_AND, EX, (l, r) => r], [FALSY, OP_AND, EX, l => l], [TRUTHY, OP_OR, EX, l => l], [FALSY, OP_OR, EX, (l, r) => r]]);\n    const left = path.get(\"left\");\n    const right = path.get(\"right\");\n    const operator = path.node.operator;\n    const result = matcher.match([left, operator, right], h.isPatternMatchesPath(t));\n\n    if (result.match) {\n      // here we are sure that left.evaluate is always confident becuase\n      // it satisfied one of TRUTHY/FALSY paths\n      let value;\n\n      if (evaluateMemo.has(left)) {\n        value = evaluateMemo.get(left).value;\n      } else {\n        value = evaluate(left).value;\n      }\n\n      path.replaceWith(result.value(t.valueToNode(value), right.node));\n    }\n  }\n\n  return {\n    simplifyPatterns\n  };\n};","\"use strict\";\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\n\nconst isPlainObject = require(\"lodash/isPlainObject\"); // the flat plugin map\n// This is to prevent dynamic requires - require('babel-plugin-' + name);\n// as it suffers during bundling of this code with webpack/browserify\n// sorted by option name\n// prettier-ignore\n\n\nconst PLUGINS = [// [optionname,         plugin,                                                          default],\n[\"booleans\", require(\"babel-plugin-transform-minify-booleans\"), true], [\"builtIns\", require(\"babel-plugin-minify-builtins\"), true], [\"consecutiveAdds\", require(\"babel-plugin-transform-inline-consecutive-adds\"), true], [\"deadcode\", require(\"babel-plugin-minify-dead-code-elimination\"), true], [\"evaluate\", require(\"babel-plugin-minify-constant-folding\"), true], [\"flipComparisons\", require(\"babel-plugin-minify-flip-comparisons\"), true], [\"guards\", require(\"babel-plugin-minify-guarded-expressions\"), true], [\"infinity\", require(\"babel-plugin-minify-infinity\"), true], [\"mangle\", require(\"babel-plugin-minify-mangle-names\"), true], [\"memberExpressions\", require(\"babel-plugin-transform-member-expression-literals\"), true], [\"mergeVars\", require(\"babel-plugin-transform-merge-sibling-variables\"), true], [\"numericLiterals\", require(\"babel-plugin-minify-numeric-literals\"), true], [\"propertyLiterals\", require(\"babel-plugin-transform-property-literals\"), true], [\"regexpConstructors\", require(\"babel-plugin-transform-regexp-constructors\"), true], [\"removeConsole\", require(\"babel-plugin-transform-remove-console\"), false], [\"removeDebugger\", require(\"babel-plugin-transform-remove-debugger\"), false], [\"removeUndefined\", require(\"babel-plugin-transform-remove-undefined\"), true], [\"replace\", require(\"babel-plugin-minify-replace\"), true], [\"simplify\", require(\"babel-plugin-minify-simplify\"), true], [\"simplifyComparisons\", require(\"babel-plugin-transform-simplify-comparison-operators\"), true], [\"typeConstructors\", require(\"babel-plugin-minify-type-constructors\"), true], [\"undefinedToVoid\", require(\"babel-plugin-transform-undefined-to-void\"), true]];\nconst PROXIES = {\n  keepFnName: [\"mangle\", \"deadcode\"],\n  keepClassName: [\"mangle\", \"deadcode\"],\n  tdz: [\"builtIns\", \"evaluate\", \"deadcode\", \"removeUndefined\"]\n};\nmodule.exports = preset;\n\nfunction preset(context, _opts = {}) {\n  const opts = isPlainObject(_opts) ? _opts : {}; // validate options\n\n  const validOptions = [...PLUGINS.map(p => p[0]), ...Object.keys(PROXIES)];\n\n  for (let name in opts) {\n    if (validOptions.indexOf(name) < 0) {\n      throw new Error(`Invalid option \"${name}\"`);\n    }\n  } // build a plugins map from the plugin table above\n\n\n  const pluginsMap = PLUGINS.reduce((acc, [name, plugin, defaultValue]) => Object.assign(acc, {\n    [name]: {\n      plugin,\n      options: null,\n      enabled: defaultValue\n    }\n  }), {}); // handle plugins and their options\n\n  var _iterator = _createForOfIteratorHelper(PLUGINS),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      const _step$value = _slicedToArray(_step.value, 1),\n            name = _step$value[0];\n\n      if (isPlainObject(opts[name])) {\n        // for plugins disabled by default\n        pluginsMap[name].enabled = true;\n        pluginsMap[name].options = opts[name];\n      } else if (opts[name] !== void 0) {\n        pluginsMap[name].enabled = !!opts[name];\n      }\n    } // handle proxies\n\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  for (let proxyname in PROXIES) {\n    if (opts[proxyname] !== void 0) {\n      var _iterator2 = _createForOfIteratorHelper(PROXIES[proxyname]),\n          _step2;\n\n      try {\n        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n          const to = _step2.value;\n\n          if (!pluginsMap[to].options) {\n            pluginsMap[to].options = {};\n          }\n\n          if (!hop(pluginsMap[to].options, proxyname)) {\n            pluginsMap[to].options[proxyname] = opts[proxyname];\n          }\n        }\n      } catch (err) {\n        _iterator2.e(err);\n      } finally {\n        _iterator2.f();\n      }\n    }\n  } // get the array of plugins\n\n\n  const plugins = Object.keys(pluginsMap).map(name => pluginsMap[name]).filter(plugin => plugin.enabled).map(plugin => plugin.options ? [plugin.plugin, plugin.options] : plugin.plugin);\n  return {\n    minified: true,\n    presets: [{\n      plugins\n    }],\n    passPerPreset: true\n  };\n}\n\nfunction hop(o, key) {\n  return Object.prototype.hasOwnProperty.call(o, key);\n}","var MapCache = require('./_MapCache'),\n    setCacheAdd = require('./_setCacheAdd'),\n    setCacheHas = require('./_setCacheHas');\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n  var index = -1,\n      length = values == null ? 0 : values.length;\n\n  this.__data__ = new MapCache;\n  while (++index < length) {\n    this.add(values[index]);\n  }\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\nmodule.exports = SetCache;\n","\"use strict\";\n\nconst _require = require(\"esutils\"),\n      keyword = _require.keyword;\n\nconst escapeStringLiteral = require(\"./escape-string-literal\");\n\nmodule.exports = {\n  reduceStaticPropertyNameES5\n};\n/**\n *\n * Original Source:\n * https://github.com/shapesecurity/shift-codegen-js/blob/0d09bd8a/src/minimal-codegen.js#L635\n *\n * This implementation modifies the original source in the following ways\n * + Check for ES5 Identifier name instead of ES6 Identifier name\n * + Use Babel-Types & Babel's AST instead of ShiftAST\n *\n * LICENSE\n\nCopyright 2014 Shape Security, Inc.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n\n */\n\nfunction reduceStaticPropertyNameES5(t, node) {\n  if (keyword.isIdentifierNameES5(node.value)) {\n    return t.Identifier(node.value);\n  }\n\n  let n = parseFloat(node.value);\n\n  if (n >= 0 && n.toString() === node.value) {\n    return t.NumericLiteral(n);\n  }\n\n  return t.Identifier(escapeStringLiteral(node.value));\n}","\"use strict\";\n\nconst Collapser = require(\"./collapser\");\n\nclass ArrayPropertyCollapser extends Collapser {\n  isInitTypeValid(init) {\n    return init.isArrayExpression();\n  }\n\n  isExpressionTypeValid(expr) {\n    return expr.isAssignmentExpression();\n  }\n\n  getExpressionChecker(objName, checkReference) {\n    return expr => {\n      // checks expr is of form:\n      // foo[num] = rval\n      const left = expr.get(\"left\");\n\n      if (!left.isMemberExpression()) {\n        return false;\n      }\n\n      const obj = left.get(\"object\"),\n            prop = left.get(\"property\");\n\n      if (!obj.isIdentifier() || obj.node.name !== objName) {\n        return false;\n      }\n\n      const checkIndex = num => Number.isInteger(num) && num >= 0;\n\n      if (!(prop.isNumericLiteral() || prop.isStringLiteral()) || !checkIndex(Number(prop.node.value))) {\n        return false;\n      }\n\n      const right = expr.get(\"right\");\n\n      if (checkReference(right)) {\n        return false;\n      }\n\n      return true;\n    };\n  }\n\n  extractAssignment(expr) {\n    return [expr.node.left.property.value, expr.get(\"right\")];\n  }\n\n  addSuccessfully(t, [index, rval], init) {\n    const elements = init.elements;\n\n    for (let i = elements.length; i <= index; i++) {\n      elements.push(null);\n    }\n\n    if (elements[index] !== null) {\n      return false;\n    }\n\n    elements[index] = rval.node;\n    return true;\n  }\n\n  isSizeSmaller({\n    newInit,\n    oldInit,\n    varDecl,\n    assignments,\n    statements\n  }) {\n    const anyUndefined = args => args.some(a => a === undefined); // We make an inexact calculation of how much space we save.\n    // It's inexact because we don't know how whitespaces will get minimized,\n    // and other factors.\n\n\n    if (anyUndefined([statements[statements.length - 1].node.end, varDecl.node.end])) {\n      return false;\n    }\n\n    const statementsLength = statements[statements.length - 1].node.end - varDecl.node.end; // Approx. formula of the change in `init`'s length =\n    // (# commas added) + (size of all the new rvals added), where\n    // # commas added = (difference between the lengths of the old and new arrays)\n\n    const numCommaAdded = newInit.elements.length - oldInit.elements.length;\n\n    if (anyUndefined(assignments.map(([, rval]) => rval.node.end)) || anyUndefined(assignments.map(([, rval]) => rval.node.start))) {\n      return false;\n    }\n\n    const sizeOfRvals = assignments.map(([, rval]) => rval.node.end - rval.node.start + 1).reduce((a, b) => a + b, 0); // add 1 for space in front // sum\n\n    return numCommaAdded + sizeOfRvals < statementsLength;\n  }\n\n}\n\nmodule.exports = ArrayPropertyCollapser;","/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n  return this.__data__.has(value);\n}\n\nmodule.exports = setCacheHas;\n","\"use strict\";\n\nconst evaluate = require(\"babel-helper-evaluate-path\");\n\nfunction isPureAndUndefined(rval, {\n  tdz,\n  scope = {\n    hasBinding: () => false\n  }\n} = {}) {\n  if (rval.isIdentifier() && rval.node.name === \"undefined\") {\n    // deopt right away if undefined is a local binding\n    if (scope.hasBinding(rval.node.name, true\n    /* no globals */\n    )) {\n      return false;\n    }\n\n    return true;\n  }\n\n  if (!rval.isPure()) {\n    return false;\n  }\n\n  const evaluation = evaluate(rval, {\n    tdz\n  });\n  return evaluation.confident === true && evaluation.value === undefined;\n}\n\nfunction getLoopParent(path, scopeParent) {\n  const parent = path.findParent(p => p.isLoop() || p === scopeParent); // don't traverse higher than the function the var is defined in.\n\n  return parent === scopeParent ? null : parent;\n}\n\nfunction getFunctionParent(path, scopeParent) {\n  const parent = path.findParent(p => p.isFunction()); // don't traverse higher than the function the var is defined in.\n\n  return parent === scopeParent ? null : parent;\n}\n\nfunction getFunctionReferences(path, scopeParent, references = new Set()) {\n  for (let func = getFunctionParent(path, scopeParent); func; func = getFunctionParent(func, scopeParent)) {\n    const id = func.node.id;\n    const binding = id && func.scope.getBinding(id.name);\n\n    if (!binding) {\n      continue;\n    }\n\n    binding.referencePaths.forEach(path => {\n      if (!references.has(path)) {\n        references.add(path);\n        getFunctionReferences(path, scopeParent, references);\n      }\n    });\n  }\n\n  return references;\n}\n\nfunction hasViolation(declarator, scope, start) {\n  const binding = scope.getBinding(declarator.node.id.name);\n\n  if (!binding) {\n    return true;\n  }\n\n  const scopeParent = declarator.getFunctionParent();\n  const violation = binding.constantViolations.some(v => {\n    // https://github.com/babel/minify/issues/630\n    if (!v.node) {\n      return false;\n    } // return 'true' if we cannot guarantee the violation references\n    // the initialized identifier after\n\n\n    const violationStart = v.node.start;\n\n    if (violationStart === undefined || violationStart < start) {\n      return true;\n    }\n\n    const references = getFunctionReferences(v, scopeParent);\n    var _iteratorNormalCompletion = true;\n    var _didIteratorError = false;\n    var _iteratorError = undefined;\n\n    try {\n      for (var _iterator = references[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n        const ref = _step.value;\n\n        if (ref.node.start === undefined || ref.node.start < start) {\n          return true;\n        }\n      }\n    } catch (err) {\n      _didIteratorError = true;\n      _iteratorError = err;\n    } finally {\n      try {\n        if (!_iteratorNormalCompletion && _iterator.return != null) {\n          _iterator.return();\n        }\n      } finally {\n        if (_didIteratorError) {\n          throw _iteratorError;\n        }\n      }\n    }\n\n    for (let loop = getLoopParent(declarator, scopeParent); loop; loop = getLoopParent(loop, scopeParent)) {\n      if (loop.node.end === undefined || loop.node.end > violationStart) {\n        return true;\n      }\n    }\n  });\n  return violation;\n}\n\nmodule.exports = function () {\n  return {\n    name: \"transform-remove-undefined\",\n    visitor: {\n      SequenceExpression(path, {\n        opts: {\n          tdz\n        } = {}\n      }) {\n        const expressions = path.get(\"expressions\");\n\n        for (let i = 0; i < expressions.length; i++) {\n          const expr = expressions[i];\n          if (!isPureAndUndefined(expr, {\n            tdz,\n            scope: path.scope\n          })) continue; // last value\n\n          if (i === expressions.length - 1) {\n            if (path.parentPath.isExpressionStatement()) {\n              expr.remove();\n            }\n          } else {\n            expr.remove();\n          }\n        }\n      },\n\n      ReturnStatement(path, {\n        opts: {\n          tdz\n        } = {}\n      }) {\n        if (path.node.argument !== null) {\n          if (isPureAndUndefined(path.get(\"argument\"), {\n            tdz,\n            scope: path.scope\n          })) {\n            path.node.argument = null;\n          }\n        }\n      },\n\n      VariableDeclaration(path, {\n        opts: {\n          tdz\n        } = {}\n      }) {\n        switch (path.node.kind) {\n          case \"const\":\n            break;\n\n          case \"let\":\n            var _iteratorNormalCompletion2 = true;\n            var _didIteratorError2 = false;\n            var _iteratorError2 = undefined;\n\n            try {\n              for (var _iterator2 = path.get(\"declarations\")[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {\n                const declarator = _step2.value;\n\n                if (isPureAndUndefined(declarator.get(\"init\"), {\n                  tdz\n                })) {\n                  declarator.node.init = null;\n                }\n              }\n            } catch (err) {\n              _didIteratorError2 = true;\n              _iteratorError2 = err;\n            } finally {\n              try {\n                if (!_iteratorNormalCompletion2 && _iterator2.return != null) {\n                  _iterator2.return();\n                }\n              } finally {\n                if (_didIteratorError2) {\n                  throw _iteratorError2;\n                }\n              }\n            }\n\n            break;\n\n          case \"var\":\n            const start = path.node.start;\n\n            if (start === undefined) {\n              // This is common for plugin-generated nodes\n              break;\n            }\n\n            const scope = path.scope;\n            var _iteratorNormalCompletion3 = true;\n            var _didIteratorError3 = false;\n            var _iteratorError3 = undefined;\n\n            try {\n              for (var _iterator3 = path.get(\"declarations\")[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {\n                const declarator = _step3.value;\n\n                if (isPureAndUndefined(declarator.get(\"init\")) && !hasViolation(declarator, scope, start)) {\n                  declarator.node.init = null;\n                }\n              }\n            } catch (err) {\n              _didIteratorError3 = true;\n              _iteratorError3 = err;\n            } finally {\n              try {\n                if (!_iteratorNormalCompletion3 && _iterator3.return != null) {\n                  _iterator3.return();\n                }\n              } finally {\n                if (_didIteratorError3) {\n                  throw _iteratorError3;\n                }\n              }\n            }\n\n            break;\n        }\n      }\n\n    }\n  };\n};","\"use strict\";\n\nmodule.exports = ({\n  types: t\n}) => {\n  const NO_MEMBER = Symbol(\"no member\");\n  const replaceVisitor = {\n    ReferencedIdentifier(path) {\n      const _path = path,\n            node = _path.node;\n      const optionsMap = this.replacements[node.name];\n\n      if (!optionsMap) {\n        return;\n      }\n\n      let options;\n\n      if (path.parentPath.isMemberExpression({\n        object: node\n      })) {\n        const property = path.parent.property;\n        const key = t.isIdentifier(property) && property.name;\n\n        if (typeof key === \"string\") {\n          options = optionsMap[key];\n          path = path.parentPath;\n        }\n      }\n\n      if (!options) {\n        options = optionsMap[NO_MEMBER];\n      }\n\n      if (!options) {\n        return;\n      }\n\n      path.replaceWith(options.node);\n    }\n\n  };\n  return {\n    name: \"minify-replace\",\n    visitor: {\n      Program(path) {\n        /**\n           Replacements is an array of objects like this:\n           {\n             identifierName: 'console',\n             member: 'log', // optional\n             replacement: {\n               type: 'identifier',\n               value: '',\n             },\n           }\n        **/\n        if (!this.opts.replacements) {\n          // No replacements. Bail.\n          return;\n        }\n\n        const map = Object.create(null);\n        this.opts.replacements.forEach(({\n          identifierName,\n          replacement,\n          member\n        }) => {\n          if (path.scope.globals[identifierName]) {\n            // Convert to a node, we only allow identifiers and literals as replacements\n            if (!replacement.type.match(/literal|identifier/i)) {\n              throw new Error(\"Only literals and identifier are supported as replacements\");\n            }\n\n            const node = t[replacement.type](replacement.value);\n            const options = {\n              identifierName,\n              node,\n              member\n            };\n\n            if (!map[identifierName]) {\n              map[identifierName] = {};\n            }\n\n            if (member && map[identifierName][member]) {\n              throw new Error(`Replacement collision ${identifierName}.${member}`);\n            }\n\n            map[identifierName][member || NO_MEMBER] = options;\n          }\n        });\n        path.traverse(replaceVisitor, {\n          replacements: map\n        });\n      }\n\n    }\n  };\n};","var castPath = require('./_castPath'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isIndex = require('./_isIndex'),\n    isLength = require('./isLength'),\n    toKey = require('./_toKey');\n\n/**\n * Checks if `path` exists on `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @param {Function} hasFunc The function to check properties.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n */\nfunction hasPath(object, path, hasFunc) {\n  path = castPath(path, object);\n\n  var index = -1,\n      length = path.length,\n      result = false;\n\n  while (++index < length) {\n    var key = toKey(path[index]);\n    if (!(result = object != null && hasFunc(object, key))) {\n      break;\n    }\n    object = object[key];\n  }\n  if (result || ++index != length) {\n    return result;\n  }\n  length = object == null ? 0 : object.length;\n  return !!length && isLength(length) && isIndex(key, length) &&\n    (isArray(object) || isArguments(object));\n}\n\nmodule.exports = hasPath;\n","var isArray = require('./isArray'),\n    isKey = require('./_isKey'),\n    stringToPath = require('./_stringToPath'),\n    toString = require('./toString');\n\n/**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {Object} [object] The object to query keys on.\n * @returns {Array} Returns the cast property path array.\n */\nfunction castPath(value, object) {\n  if (isArray(value)) {\n    return value;\n  }\n  return isKey(value, object) ? [value] : stringToPath(toString(value));\n}\n\nmodule.exports = castPath;\n","var MapCache = require('./_MapCache');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n  if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  var memoized = function() {\n    var args = arguments,\n        key = resolver ? resolver.apply(this, args) : args[0],\n        cache = memoized.cache;\n\n    if (cache.has(key)) {\n      return cache.get(key);\n    }\n    var result = func.apply(this, args);\n    memoized.cache = cache.set(key, result) || cache;\n    return result;\n  };\n  memoized.cache = new (memoize.Cache || MapCache);\n  return memoized;\n}\n\n// Expose `MapCache`.\nmemoize.Cache = MapCache;\n\nmodule.exports = memoize;\n","var baseGet = require('./_baseGet');\n\n/**\n * A specialized version of `baseProperty` which supports deep paths.\n *\n * @private\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction basePropertyDeep(path) {\n  return function(object) {\n    return baseGet(object, path);\n  };\n}\n\nmodule.exports = basePropertyDeep;\n","\"use strict\";\n\nconst EVAL_SCOPE_MARKER = Symbol(\"evalInScope\");\nmodule.exports = {\n  EVAL_SCOPE_MARKER,\n  getEvalScopes,\n  markEvalScopes,\n  isMarked,\n  hasEval\n};\n\nfunction getEvalScopes(path) {\n  const evalScopes = new Set();\n\n  function add(scope) {\n    let evalScope = scope;\n\n    do {\n      evalScopes.add(evalScope);\n    } while (evalScope = evalScope.parent);\n  }\n\n  path.traverse({\n    CallExpression(evalPath) {\n      const callee = evalPath.get(\"callee\");\n\n      if (callee.isIdentifier() && callee.node.name === \"eval\" && !callee.scope.getBinding(\"eval\")) {\n        add(callee.scope);\n      }\n    }\n\n  });\n  return evalScopes;\n}\n\nfunction markEvalScopes(path, key = EVAL_SCOPE_MARKER) {\n  const evalScopes = getEvalScopes(path);\n  [...evalScopes].forEach(scope => {\n    scope[key] = true;\n  });\n}\n\nfunction isMarked(scope, key = EVAL_SCOPE_MARKER) {\n  return Object.prototype.hasOwnProperty.call(scope, key);\n}\n\nfunction hasEval(scope, key = EVAL_SCOPE_MARKER) {\n  if (!isMarked(scope, key)) {\n    markEvalScopes(scope, key);\n  }\n\n  return scope[key];\n}","/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\nmodule.exports = mapToArray;\n","/**\n * The base implementation of `_.property` without support for deep paths.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction baseProperty(key) {\n  return function(object) {\n    return object == null ? undefined : object[key];\n  };\n}\n\nmodule.exports = baseProperty;\n","\"use strict\";\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\n\nconst Charset = require(\"./charset\");\n\nconst ScopeTracker = require(\"./scope-tracker\");\n\nconst isLabelIdentifier = require(\"./is-label-identifier\");\n\nconst bfsTraverseCreator = require(\"./bfs-traverse\");\n\nconst fixupVarScoping = require(\"./fixup-var-scoping\");\n\nconst _require = require(\"babel-helper-mark-eval-scopes\"),\n      markEvalScopes = _require.markEvalScopes,\n      isEvalScopesMarked = _require.isMarked,\n      hasEval = _require.hasEval;\n\nconst newIssueUrl = \"https://github.com/babel/minify/issues/new\";\n\nmodule.exports = babel => {\n  const t = babel.types,\n        traverse = babel.traverse;\n  const bfsTraverse = bfsTraverseCreator(babel);\n  const hop = Object.prototype.hasOwnProperty;\n\n  class Mangler {\n    constructor(charset, program, {\n      exclude = {},\n      keepFnName = false,\n      keepClassName = false,\n      eval: _eval = false,\n      topLevel = false\n    } = {}) {\n      this.charset = charset;\n      this.program = program; // user passed options\n\n      this.exclude = toObject(exclude);\n      this.keepFnName = keepFnName;\n      this.keepClassName = keepClassName;\n      this.topLevel = topLevel;\n      this.eval = _eval; // tracking\n\n      this.visitedScopes = new Set();\n      this.scopeTracker = new ScopeTracker();\n      this.renamedNodes = new Set();\n    }\n    /**\n     * Run the mangler\n     */\n\n\n    run() {\n      this.crawlScope();\n      this.collect();\n      this.fixup();\n      this.charset.sort();\n      this.mangle();\n    }\n    /**\n     * Tells if a variable name is excluded\n     * @param {String} name\n     */\n\n\n    isExcluded(name) {\n      return hop.call(this.exclude, name) && this.exclude[name];\n    }\n    /**\n     * Clears traverse cache and recrawls the AST\n     *\n     * to recompute the bindings, references, other scope information\n     * and paths because the other transformations in the same pipeline\n     * (other plugins and presets) changes the AST and does NOT update\n     * the scope objects\n     */\n\n\n    crawlScope() {\n      (traverse.clearCache || traverse.cache.clear)();\n      this.program.scope.crawl();\n    }\n    /**\n     * Re-crawling comes with a side-effect that let->var conversion\n     * reverts the update of the binding information (block to fn scope).\n     * This function takes care of it by updating it again.\n     *\n     * TODO: This is unnecessary work and needs to be fixed in babel.\n     * https://github.com/babel/babel/issues/4818\n     *\n     * When this is removed, remember to remove fixup's dependency in\n     * ScopeTracker\n     */\n\n\n    fixup() {\n      fixupVarScoping(this);\n    }\n    /**\n     * A single pass through the AST to collect info for\n     *\n     * 1. Scope Tracker\n     * 2. Unsafe Scopes (direct eval scopes)\n     * 3. Charset considerations for better gzip compression\n     *\n     * Traversed in the same fashion(BFS) the mangling is done\n     */\n\n\n    collect() {\n      const mangler = this;\n      const scopeTracker = mangler.scopeTracker;\n      scopeTracker.addScope(this.program.scope);\n      /**\n       * Same usage as in DCE, whichever runs first\n       */\n\n      if (!isEvalScopesMarked(mangler.program)) {\n        markEvalScopes(mangler.program);\n      }\n      /**\n       * The visitors to be used in traversal.\n       *\n       * Note: BFS traversal supports only the `enter` handlers, `exit`\n       * handlers are simply dropped without Errors\n       *\n       * Collects items defined in the ScopeTracker\n       */\n\n\n      const collectVisitor = {\n        Scopable({\n          scope\n        }) {\n          scopeTracker.addScope(scope); // Collect bindings defined in the scope\n\n          Object.keys(scope.bindings).forEach(name => {\n            scopeTracker.addBinding(scope.bindings[name]); // add all constant violations as references\n\n            scope.bindings[name].constantViolations.forEach(() => {\n              scopeTracker.addReference(scope, scope.bindings[name], name);\n            });\n          });\n        },\n\n        /**\n         * This is required because after function name transformation\n         * plugin (part of es2015), the function name is NOT added to the\n         * scope's bindings. So to fix this issue, we simply add a hack to\n         * handle that case - fix it to the scope tree.\n         *\n         * Related:\n         * - https://github.com/babel/minify/issues/829\n         */\n        BindingIdentifier(path) {\n          if ( // the parent has this id as the name\n          (path.parentPath.isFunctionExpression({\n            id: path.node\n          }) || path.parentPath.isClassExpression({\n            id: path.node\n          })) && // and the id isn't yet added to the scope\n          !hop.call(path.parentPath.scope.bindings, path.node.name)) {\n            path.parentPath.scope.registerBinding(\"local\", path.parentPath);\n          }\n        },\n\n        /**\n         * This is necessary because, in Babel, the scope.references\n         * does NOT contain the references in that scope. Only the program\n         * scope (top most level) contains all the references.\n         *\n         * We collect the references in a fashion where all the scopes between\n         * and including the referenced scope and scope where it is declared\n         * is considered as scope referencing that identifier\n         */\n        ReferencedIdentifier(path) {\n          if (isLabelIdentifier(path)) {\n            return;\n          }\n\n          const scope = path.scope,\n                name = path.node.name;\n          const binding = scope.getBinding(name);\n\n          if (!binding) {\n            // Do not collect globals as they are already available via\n            // babel's API\n            if (scope.hasGlobal(name)) {\n              return;\n            } // This should NOT happen ultimately. Panic if this code block is\n            // reached\n\n\n            throw new Error(`Binding not found for ReferencedIdentifier \"${name}\" ` + `present in \"${path.parentPath.type}\". ` + `Please report this at ${newIssueUrl}`);\n          } else {\n            // Add it to our scope tracker if everything is fine\n            scopeTracker.addReference(scope, binding, name);\n          }\n        }\n\n      };\n      /**\n       * These visitors are for collecting the Characters used in the program\n       * to measure the frequency and generate variable names for mangling so\n       * as to improve the gzip compression - as gzip likes repetition\n       */\n\n      if (this.charset.shouldConsider) {\n        collectVisitor.Identifier = function Identifer(path) {\n          const node = path.node; // We don't mangle properties, so we collect them as they contribute\n          // to the frequency of characters\n\n          if (path.parentPath.isMemberExpression({\n            property: node\n          }) || path.parentPath.isObjectProperty({\n            key: node\n          })) {\n            mangler.charset.consider(node.name);\n          }\n        };\n\n        collectVisitor.Literal = function Literal({\n          node\n        }) {\n          mangler.charset.consider(String(node.value));\n        };\n      } // Traverse the AST\n\n\n      bfsTraverse(mangler.program, collectVisitor);\n    }\n    /**\n     * Tells if a binding is exported as a NamedExport - so as to NOT mangle\n     *\n     * Babel treats NamedExports as a binding referenced by this NamedExport decl\n     * @param {Binding} binding\n     */\n\n\n    isExportedWithName(binding) {\n      // short circuit\n      if (!this.topLevel) {\n        return false;\n      }\n\n      const refs = binding.referencePaths;\n\n      var _iterator = _createForOfIteratorHelper(refs),\n          _step;\n\n      try {\n        for (_iterator.s(); !(_step = _iterator.n()).done;) {\n          const ref = _step.value;\n\n          if (ref.isExportNamedDeclaration()) {\n            return true;\n          }\n        } // default\n\n      } catch (err) {\n        _iterator.e(err);\n      } finally {\n        _iterator.f();\n      }\n\n      return false;\n    }\n    /**\n     * Tells if the name can be mangled in the current observed scope with\n     * the input binding\n     *\n     * @param {string} oldName the old name that needs to be mangled\n     * @param {Binding} binding Binding of the name\n     * @param {Scope} scope The current scope the mangler is run\n     */\n\n\n    canMangle(oldName, binding, scope) {\n      const cannotMangle = // arguments - for non-strict mode\n      oldName === \"arguments\" || // labels\n      binding.path.isLabeledStatement() || // ClassDeclaration has binding in two scopes\n      //   1. The scope in which it is declared\n      //   2. The class's own scope\n      binding.path.isClassDeclaration() && binding.path === scope.path || // excluded\n      this.isExcluded(oldName) || ( // function names\n      this.keepFnName ? isFunction(binding.path) : false) || ( // class names\n      this.keepClassName ? isClass(binding.path) : false) || // named export\n      this.isExportedWithName(binding);\n      return !cannotMangle;\n    }\n    /**\n     * Tells if the newName can be used as a valid name for the input binding\n     * in the input scope\n     *\n     * @param {string} newName the old name that needs to be mangled\n     * @param {Binding} binding Binding of the name that this new name will replace\n     * @param {Scope} scope The current scope the mangler is run\n     */\n\n\n    isValidName(newName, binding, scope) {\n      return t.isValidIdentifier(newName) && !this.scopeTracker.hasBinding(scope, newName) && !scope.hasGlobal(newName) && !this.scopeTracker.hasReference(scope, newName) && this.scopeTracker.canUseInReferencedScopes(binding, newName);\n    }\n    /**\n     * Mangle the scope\n     * @param {Scope} scope\n     */\n\n\n    mangleScope(scope) {\n      const mangler = this;\n      const scopeTracker = mangler.scopeTracker; // Unsafe Scope\n\n      if (!mangler.eval && hasEval(scope)) {\n        return;\n      } // Already visited\n      // This is because for a function, in Babel, the function and\n      // the function body's BlockStatement has the same scope, and will\n      // be visited twice by the Scopable handler, and we want to mangle\n      // it only once\n\n\n      if (mangler.visitedScopes.has(scope)) {\n        return;\n      }\n\n      mangler.visitedScopes.add(scope);\n      const bindings = scopeTracker.bindings.get(scope);\n      const names = [...bindings.keys()]; // A counter to generate names and reset\n      // so we can reuse removed names\n\n      let counter = 0;\n      /**\n       * 1. Iterate through the list of BindingIdentifiers\n       * 2. Rename each of them in-place\n       * 3. Update the scope tree.\n       *\n       * We cannot use a for..of loop over bindings.keys()\n       * because (2) we rename in place and update the bindings\n       * as we traverse through the keys\n       */\n\n      for (var _i = 0, _names = names; _i < _names.length; _i++) {\n        const oldName = _names[_i];\n        const binding = bindings.get(oldName);\n\n        if (mangler.canMangle(oldName, binding, scope)) {\n          let next;\n\n          do {\n            next = mangler.charset.getIdentifier(counter++);\n          } while (!mangler.isValidName(next, binding, scope)); // Reset so variables which are removed can be reused\n          //\n          // the following is an assumtion (for perf)\n          // the length 3 is an assumption that if the oldName isn't\n          // 1 or 2 characters, then probably we are not going to find\n          // a name - because for almost all usecases we have 1 or 2\n          // character new names only. And for the edge cases where\n          // one scope has lots and lots of variables, it's okay to\n          // name something with 3 characters instead of 1\n\n\n          if (oldName.length < 3) {\n            counter = 0;\n          } // Once we detected a valid `next` Identifier which could be used,\n          // call the renamer\n\n\n          mangler.rename(scope, binding, oldName, next);\n        }\n      }\n    }\n    /**\n     * The mangle function that traverses through all the Scopes in a BFS\n     * fashion - calls mangleScope\n     */\n\n\n    mangle() {\n      const mangler = this;\n      bfsTraverse(this.program, {\n        Scopable(path) {\n          if (!path.isProgram() || mangler.topLevel) mangler.mangleScope(path.scope);\n        }\n\n      });\n    }\n    /**\n     * Given a NodePath, collects all the Identifiers which are BindingIdentifiers\n     * and replaces them with the new name\n     *\n     * For example,\n     *   var a = 1, { b } = c; // a and b are BindingIdentifiers\n     *\n     * @param {NodePath} path\n     * @param {String} oldName\n     * @param {String} newName\n     * @param {Function} predicate\n     */\n\n\n    renameBindingIds(path, oldName, newName, predicate = () => true) {\n      const bindingIds = path.getBindingIdentifierPaths(true, false);\n\n      for (const name in bindingIds) {\n        if (name !== oldName) continue;\n\n        var _iterator2 = _createForOfIteratorHelper(bindingIds[name]),\n            _step2;\n\n        try {\n          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n            const idPath = _step2.value;\n\n            if (predicate(idPath)) {\n              idPath.node.name = newName; // babel-7 don't requeue\n              // idPath.replaceWith(t.identifier(newName));\n\n              this.renamedNodes.add(idPath.node);\n            }\n          }\n        } catch (err) {\n          _iterator2.e(err);\n        } finally {\n          _iterator2.f();\n        }\n      }\n    }\n    /**\n     * The Renamer:\n     * Renames the following for one Binding in a Scope\n     *\n     * 1. Binding in that Scope\n     * 2. All the Binding's constant violations\n     * 3. All its References\n     * 4. Updates mangler.scopeTracker\n     * 5. Updates Babel's Scope tracking\n     *\n     * @param {Scope} scope\n     * @param {Binding} binding\n     * @param {String} oldName\n     * @param {String} newName\n     */\n\n\n    rename(scope, binding, oldName, newName) {\n      const mangler = this;\n      const scopeTracker = mangler.scopeTracker; // rename at the declaration level\n\n      this.renameBindingIds(binding.path, oldName, newName, idPath => idPath.node === binding.identifier); // update mangler's ScopeTracker\n\n      scopeTracker.renameBinding(scope, oldName, newName); // update all constant violations\n\n      const violations = binding.constantViolations;\n\n      for (let i = 0; i < violations.length; i++) {\n        if (violations[i].isLabeledStatement()) continue;\n        this.renameBindingIds(violations[i], oldName, newName);\n        scopeTracker.updateReference(violations[i].scope, binding, oldName, newName);\n      } // update all referenced places\n\n\n      const refs = binding.referencePaths;\n\n      for (let i = 0; i < refs.length; i++) {\n        const path = refs[i];\n        const node = path.node;\n\n        if (!path.isIdentifier()) {\n          // Ideally, this should not happen\n          // it happens in these places now -\n          // case 1: Export Statements\n          // This is a bug in babel\n          // https://github.com/babel/babel/pull/3629\n          // case 2: Replacements in other plugins\n          // eg: https://github.com/babel/minify/issues/122\n          // replacement in dce from `x` to `!x` gives referencePath as `!x`\n          path.traverse({\n            ReferencedIdentifier(refPath) {\n              if (refPath.node.name !== oldName) {\n                return;\n              }\n\n              const actualBinding = refPath.scope.getBinding(oldName);\n\n              if (actualBinding !== binding) {\n                return;\n              }\n\n              refPath.node.name = newName; // babel-7 don't requeue\n              // refPath.replaceWith(t.identifier(newName));\n\n              mangler.renamedNodes.add(refPath.node);\n              scopeTracker.updateReference(refPath.scope, binding, oldName, newName);\n            }\n\n          });\n        } else if (!isLabelIdentifier(path)) {\n          if (path.node.name === oldName) {\n            path.node.name = newName; // babel-7 don't requeue\n            // path.replaceWith(t.identifier(newName));\n\n            mangler.renamedNodes.add(path.node);\n            scopeTracker.updateReference(path.scope, binding, oldName, newName);\n          } else if (mangler.renamedNodes.has(path.node)) {\n            // already renamed,\n            // just update the references\n            scopeTracker.updateReference(path.scope, binding, oldName, newName);\n          } else {\n            throw new Error(`Unexpected Rename Error: ` + `Trying to replace \"${node.name}\": from \"${oldName}\" to \"${newName}\". ` + `Please report it at ${newIssueUrl}`);\n          }\n        } // else label identifier - silently ignore\n\n      } // update babel's internal tracking\n\n\n      binding.identifier.name = newName; // update babel's internal scope tracking\n\n      const bindings = scope.bindings;\n      bindings[newName] = binding;\n      delete bindings[oldName];\n    }\n\n  }\n\n  return {\n    name: \"minify-mangle-names\",\n    visitor: {\n      /**\n       * Mangler is run as a single pass. It's the same pattern as used in DCE\n       */\n      Program: {\n        exit(path) {\n          // If the source code is small then we're going to assume that the user\n          // is running on this on single files before bundling. Therefore we\n          // need to achieve as much determinisim and we will not do any frequency\n          // sorting on the character set. Currently the number is pretty arbitrary.\n          const shouldConsiderSource = path.getSource().length > 70000;\n          const charset = new Charset(shouldConsiderSource);\n          const mangler = new Mangler(charset, path, this.opts);\n          mangler.run();\n        }\n\n      }\n    }\n  };\n}; // convert value to object\n\n\nfunction toObject(value) {\n  if (!Array.isArray(value)) {\n    return value;\n  }\n\n  const map = {};\n\n  for (let i = 0; i < value.length; i++) {\n    map[value[i]] = true;\n  }\n\n  return map;\n} // for keepFnName\n\n\nfunction isFunction(path) {\n  return path.isFunctionExpression() || path.isFunctionDeclaration();\n} // for keepClassName\n\n\nfunction isClass(path) {\n  return path.isClassExpression() || path.isClassDeclaration();\n}","\"use strict\";\n\nmodule.exports = function () {\n  return {\n    name: \"transform-remove-debugger\",\n    visitor: {\n      DebuggerStatement(path) {\n        path.remove();\n      }\n\n    }\n  };\n};","var isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n  if (typeof value == 'string' || isSymbol(value)) {\n    return value;\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nmodule.exports = toKey;\n","var isArray = require('./isArray'),\n    isSymbol = require('./isSymbol');\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n    reIsPlainProp = /^\\w*$/;\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n  if (isArray(value)) {\n    return false;\n  }\n  var type = typeof value;\n  if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n      value == null || isSymbol(value)) {\n    return true;\n  }\n  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n    (object != null && value in Object(object));\n}\n\nmodule.exports = isKey;\n","var baseProperty = require('./_baseProperty'),\n    basePropertyDeep = require('./_basePropertyDeep'),\n    isKey = require('./_isKey'),\n    toKey = require('./_toKey');\n\n/**\n * Creates a function that returns the value at `path` of a given object.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n * @example\n *\n * var objects = [\n *   { 'a': { 'b': 2 } },\n *   { 'a': { 'b': 1 } }\n * ];\n *\n * _.map(objects, _.property('a.b'));\n * // => [2, 1]\n *\n * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n * // => [1, 2]\n */\nfunction property(path) {\n  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n}\n\nmodule.exports = property;\n","\"use strict\";\n\nconst _require = require(\"./property-name\"),\n      reduceStaticPropertyNameES5 = _require.reduceStaticPropertyNameES5;\n\nmodule.exports = function ({\n  types: t\n}) {\n  return {\n    name: \"transform-property-literals\",\n    visitor: {\n      // { 'foo': 'bar' } -> { foo: 'bar' }\n      ObjectProperty: {\n        exit(path) {\n          const key = path.get(\"key\");\n\n          if (!key.isStringLiteral()) {\n            return;\n          }\n\n          const newNode = t.clone(path.node);\n          newNode.key = reduceStaticPropertyNameES5(t, key.node);\n          newNode.computed = false;\n          path.replaceWith(newNode);\n        }\n\n      }\n    }\n  };\n};"],"sourceRoot":""}