{"version":3,"sources":["jsdelivr-header.js","/npm/vue-2-crumbs@0.5.4/index.js"],"names":[],"mappings":"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","file":"/npm/vue-2-crumbs@0.5.4/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/vue-2-crumbs@0.5.4/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Vue2Crumbs\"] = factory();\n\telse\n\t\troot[\"Vue2Crumbs\"] = factory();\n})(typeof self !== 'undefined' ? self : this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _breadcrumbComponent = __webpack_require__(1);\n\nvar _breadcrumbComponent2 = _interopRequireDefault(_breadcrumbComponent);\n\nvar _lodash = __webpack_require__(2);\n\nvar _lodash2 = _interopRequireDefault(_lodash);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nvar vue2Crumbs = {\n  version: '0.5.3',\n  install: function install(Vue, options) {\n    function $_vue2Crumbs_dispatchNewValue(meta) {\n      var _$breadcrumb = this.$breadcrumb,\n          label = _$breadcrumb.label,\n          parentsList = _$breadcrumb.parentsList,\n          parent = _$breadcrumb.parent,\n          utils = _$breadcrumb.utils;\n\n\n      if (!meta.breadcrumb) {\n        meta.breadcrumb = {};\n      }\n\n      var metaBreadcrumb = meta.breadcrumb;\n\n      if (typeof metaBreadcrumb === 'string') {\n        metaBreadcrumb = {\n          label: metaBreadcrumb\n        };\n      }\n\n      if (label) {\n        metaBreadcrumb.label = label;\n      }\n\n      if (parent) {\n        metaBreadcrumb.parent = parent;\n      }\n\n      if (parentsList) {\n        metaBreadcrumb.parentsList = parentsList;\n      }\n      if (utils) {\n        metaBreadcrumb.utils = utils;\n      }\n\n      this.$_vue2Crumbs_eventBUS.$emit('breadcrumbChanged');\n    }\n\n    function $_vue2Crumbs_checkMatchedRoutes() {\n      if (this.$breadcrumb) {\n        var matchedRoutes = [].concat(_toConsumableArray(this.$route.matched)).reverse();\n        var _iteratorNormalCompletion = true;\n        var _didIteratorError = false;\n        var _iteratorError = undefined;\n\n        try {\n          for (var _iterator = matchedRoutes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n            var route = _step.value;\n\n            var routeComponentInstance = route.instances.default;\n\n            if ((0, _lodash2.default)(routeComponentInstance, this)) {\n              $_vue2Crumbs_dispatchNewValue.call(this, route.meta);\n              break;\n            }\n          }\n        } catch (err) {\n          _didIteratorError = true;\n          _iteratorError = err;\n        } finally {\n          try {\n            if (!_iteratorNormalCompletion && _iterator.return) {\n              _iterator.return();\n            }\n          } finally {\n            if (_didIteratorError) {\n              throw _iteratorError;\n            }\n          }\n        }\n      }\n    }\n\n    Vue.prototype.$_vue2Crumbs_eventBUS = new Vue();\n\n    Vue.component(_breadcrumbComponent2.default.name, _breadcrumbComponent2.default);\n\n    Vue.mixin({\n      methods: {},\n      beforeCreate: function beforeCreate() {\n        if (typeof this.$options.breadcrumb === 'function') {\n          if (typeof this.$options.computed === 'undefined') {\n            this.$options.computed = {};\n          }\n          this.$options.computed.$breadcrumb = this.$options.breadcrumb;\n        }\n      },\n\n      watch: {\n        $route: function $route() {\n          $_vue2Crumbs_checkMatchedRoutes.call(this);\n        },\n\n        $breadcrumb: {\n          handler: function handler() {\n            $_vue2Crumbs_checkMatchedRoutes.call(this);\n          },\n\n          immediate: true\n        }\n      }\n    });\n  }\n};\n\nexports.default = vue2Crumbs;\n\n// Automatic installation if Vue has been added to the global scope.\n\nif (typeof window !== 'undefined' && window.Vue) {\n  window.Vue.use(vue2Crumbs);\n}\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\nvar utils = {\n  isObject: function isObject(checkMe) {\n    return (typeof checkMe === 'undefined' ? 'undefined' : _typeof(checkMe)) === 'object' && !Array.isArray(checkMe) && checkMe !== null;\n  }\n};\n\nexports.default = {\n  name: 'app-breadcrumbs',\n  template: '\\n    <ul\\n      class=\"breadcrumbs-container\"\\n      :is=\"container\"\\n      v-if=\"$router\"\\n    >\\n      <template v-if=\"parentRoutes.length\">\\n        <template v-for=\"route in parentRoutes\">\\n          <slot :to=\"route.to\" :label=\"route.label\" :utils=\"route.utils\">\\n            <li class=\"parent-breadcrumb\">\\n              <router-link\\n                :to=\"route.to\"\\n                exact\\n              >\\n                {{route.label}}\\n              </router-link>\\n            </li>\\n          </slot>\\n        </template>\\n      </template>\\n\\n      <li v-if=\"!isInitialEmptyRoute\" class=\"current-breadcrumb\">\\n        <slot name=\"current\" :label=\"getRouteLabel(currentRoute)\">\\n          <a>\\n            {{getRouteLabel(currentRoute)}}\\n          </a>\\n        </slot>\\n      </li>\\n    </ul>\\n  ',\n  props: {\n    container: {\n      type: String,\n      default: 'ul'\n    }\n  },\n  data: function data() {\n    return {\n      parentsDynamicRoutes: [],\n      parentHelper: ''\n    };\n  },\n\n  computed: {\n    isInitialEmptyRoute: function isInitialEmptyRoute() {\n      return this.$route.fullPath === '/' && !this.$route.matched.length;\n    },\n    currentRoute: function currentRoute() {\n      // This check is just to make sure that '$forceUpdate' would work\n      if (!this.isInitialEmptyRoute && (this.parentHelper || !this.parentHelper)) {\n        return this.$route;\n      }\n    },\n    parentRoutes: function parentRoutes() {\n      if (!this.isInitialEmptyRoute) {\n        return this.parentsDynamicRoutes.length ? this.parentsDynamicRoutes : this.getAncestorsRoutesArray(this.currentRoute);\n      }\n      return [];\n    }\n  },\n  // TODO: Write docs for each method\n  methods: {\n    // Function returns resolved page's breadcrumb property\n    getBreadcrumb: function getBreadcrumb(route) {\n      var breadcrumb = route.meta.breadcrumb;\n      var matchedRouteRecord = route.matched[route.matched.length - 1];\n      var matchedComponent = matchedRouteRecord.components.default;\n      var componentBreadcrumb = void 0;\n\n      // TODO: do a normal check for typescript-developed component\n      // Check is matched component made with typescript\n      if (typeof matchedComponent === 'function' && !!matchedComponent.super) {\n        componentBreadcrumb = matchedComponent.options.breadcrumb;\n      } else {\n        componentBreadcrumb = matchedComponent.breadcrumb;\n      }\n\n      if (componentBreadcrumb && typeof componentBreadcrumb !== 'function') {\n        if (breadcrumb && (typeof breadcrumb === 'undefined' ? 'undefined' : _typeof(breadcrumb)) == 'object') {\n          breadcrumb = Object.assign(breadcrumb, componentBreadcrumb);\n        } else {\n          breadcrumb = componentBreadcrumb;\n        }\n      }\n\n      return breadcrumb;\n    },\n\n\n    // Function return label from any breadcrumb property\n    getBreadcrumbLabel: function getBreadcrumbLabel(breadcrumb) {\n      if ((typeof breadcrumb === 'undefined' ? 'undefined' : _typeof(breadcrumb)) === 'object') {\n        return breadcrumb.label;\n      }\n      if (typeof breadcrumb === 'string') {\n        return breadcrumb;\n      }\n    },\n\n\n    // Function resolves a label of the provided route\n    getRouteLabel: function getRouteLabel(route) {\n      var routeLabel = route.name;\n      var breadcrumb = this.getBreadcrumb(route);\n      var breadcrumbLabel = this.getBreadcrumbLabel(breadcrumb);\n\n      if (breadcrumbLabel) {\n        routeLabel = breadcrumbLabel;\n      }\n\n      return routeLabel;\n    },\n\n\n    // Function resolves a utils object of the provided route\n    getRouteUtils: function getRouteUtils(route) {\n      var breadcrumb = this.getBreadcrumb(route);\n      if (breadcrumb && breadcrumb.utils) {\n        return breadcrumb.utils;\n      }\n    },\n    resolveRootParentRoute: function resolveRootParentRoute(parentRouteRecord) {\n      var parentRoutePath = parentRouteRecord.path || '/';\n\n      return this.$router.resolve({ path: parentRoutePath }).route;\n    },\n    getRootParentRoute: function getRootParentRoute(route) {\n      var rootParentRoute = void 0;\n      var matchedRoutes = route.matched;\n\n      // If second matched route is not the same with current route, return it as next parent\n      rootParentRoute = this.resolveRootParentRoute(matchedRoutes[matchedRoutes.length - 2]);\n\n      // If second matched route is the same with current route, return route after next as parent\n      if (route.path === rootParentRoute.path) {\n        rootParentRoute = this.resolveRootParentRoute(matchedRoutes[matchedRoutes.length - 3]);\n      }\n\n      return rootParentRoute;\n    },\n    getDirectParentRoute: function getDirectParentRoute(route) {\n      var breadcrumb = this.getBreadcrumb(route);\n\n      if (breadcrumb && breadcrumb.parent) {\n        var breadcrumbParent = breadcrumb.parent;\n        var routeResolveObject = void 0;\n\n        if (breadcrumbParent && breadcrumb.parentsList) {\n          console.warn('Vue-2-Crumbs Warning: You have both \\'parent\\' and \\'parentsList\\' properties for route \\'' + route.name + '\\'!\\nPlease, use just one of these per route. By default Vue-2-Crumbs plugin use \\'parent\\' property.');\n        }\n\n        if (typeof breadcrumbParent === 'string') {\n          routeResolveObject = { name: breadcrumbParent };\n        } else if (utils.isObject(breadcrumbParent)) {\n          routeResolveObject = breadcrumbParent;\n        } else {\n          console.error('Vue-2-Crumbs Error: \\'parent\\' property in breadcrumb object for \\'' + route.name + '\\' route has wrong type. Only string or object is allowed');\n        }\n\n        return this.$router.resolve(routeResolveObject).route;\n      }\n    },\n\n\n    // Function resolve a parent route if such exist\n    getParentRoute: function getParentRoute(route) {\n      var parentRoute = void 0;\n      var directParentRoute = this.getDirectParentRoute(route);\n\n      // Check if component has breadcrumb object\n      if (directParentRoute) {\n        parentRoute = directParentRoute;\n      } else if (route.matched && route.matched.length > 1) {\n        // Get Default Route Parent (if sub-routing uses)\n        parentRoute = this.getRootParentRoute(route);\n      }\n\n      return parentRoute;\n    },\n\n\n    // Function returns array of parents routes\n    getAncestorsRoutesArray: function getAncestorsRoutesArray(route) {\n      var parentRoutesArray = [];\n      var parentRoute = this.getParentRoute(route);\n\n      if (parentRoute) {\n        var path = parentRoute.path,\n            name = parentRoute.name,\n            params = parentRoute.params,\n            query = parentRoute.query,\n            hash = parentRoute.hash;\n\n        var routeObjectToAdd = {\n          to: { path: path, name: name, params: params, query: query, hash: hash },\n          label: this.getRouteLabel(parentRoute),\n          utils: this.getRouteUtils(parentRoute)\n        };\n\n        parentRoutesArray = [].concat(_toConsumableArray(this.getAncestorsRoutesArray(parentRoute)), [routeObjectToAdd]);\n      }\n\n      return parentRoutesArray;\n    }\n  },\n  watch: {\n    '$route': function $route() {\n      // Set empty component's 'parentsDynamicRoutes' property on each route change\n      this.parentsDynamicRoutes = [];\n    }\n  },\n  created: function created() {\n    var _this = this;\n\n    // Listen to the change of route breadcrumb object\n    this.$_vue2Crumbs_eventBUS.$on('breadcrumbChanged', function () {\n      var metaBreadcrumb = _this.$route.meta.breadcrumb;\n\n      if (metaBreadcrumb.parentsList) {\n        _this.parentsDynamicRoutes = [].concat(_toConsumableArray(metaBreadcrumb.parentsList)).reverse();\n      }\n      if (metaBreadcrumb.parent) {\n        _this.parentHelper = metaBreadcrumb.parent;\n      }\n      _this.$forceUpdate();\n    });\n  }\n};\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global, module) {\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n/**\n * Lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright JS Foundation and other contributors <https://js.foundation/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    asyncTag = '[object AsyncFunction]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    nullTag = '[object Null]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    proxyTag = '[object Proxy]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    undefinedTag = '[object Undefined]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = (typeof global === 'undefined' ? 'undefined' : _typeof(global)) == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = (typeof self === 'undefined' ? 'undefined' : _typeof(self)) == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = ( false ? 'undefined' : _typeof(exports)) == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && ( false ? 'undefined' : _typeof(module)) == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = function () {\n  try {\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}();\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\n/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\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\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function (value) {\n    return func(value);\n  };\n}\n\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\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\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\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function (arg) {\n    return func(transform(arg));\n  };\n}\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\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n    funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\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 detect methods masquerading as native. */\nvar maskSrcKey = function () {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? 'Symbol(src)_1.' + uid : '';\n}();\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&').replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$');\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    _Symbol = root.Symbol,\n    Uint8Array = root.Uint8Array,\n    propertyIsEnumerable = objectProto.propertyIsEnumerable,\n    splice = arrayProto.splice,\n    symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols,\n    nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n    nativeKeys = overArg(Object.keys, Object);\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView'),\n    Map = getNative(root, 'Map'),\n    Promise = getNative(root, 'Promise'),\n    Set = getNative(root, 'Set'),\n    WeakMap = getNative(root, 'WeakMap'),\n    nativeCreate = getNative(Object, 'create');\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\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 * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\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 hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;\n  return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\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 listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash(),\n    'map': new (Map || ListCache)(),\n    'string': new Hash()\n  };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\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 mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\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/**\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\n/**\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\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache();\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\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 stackHas(key) {\n  return this.__data__.has(key);\n}\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (\n    // Safari 9 has enumerable `arguments.length` in strict mode.\n    key == 'length' ||\n    // Node.js 0.10 has enumerable non-index properties on buffers.\n    isBuff && (key == 'offset' || key == 'parent') ||\n    // PhantomJS 2 has enumerable non-index properties on typed arrays.\n    isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset') ||\n    // Skip index properties.\n    isIndex(key, length)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);\n}\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\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\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) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : 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\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\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  // Assume cyclic values are equal.\n  var stacked = stack.get(array);\n  if (stacked && stack.get(other)) {\n    return stacked == other;\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 ? customizer(othValue, arrValue, index, other, array, stack) : 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) && (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n          return seen.push(othIndex);\n        }\n      })) {\n        result = false;\n        break;\n      }\n    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n      result = false;\n      break;\n    }\n  }\n  stack['delete'](array);\n  stack['delete'](other);\n  return result;\n}\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 || 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 || !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\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  // Assume cyclic values are equal.\n  var stacked = stack.get(object);\n  if (stacked && stack.get(other)) {\n    return stacked == other;\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 ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);\n    }\n    // Recursively compare objects (susceptible to call stack limits).\n    if (!(compared === undefined ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {\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 && 'constructor' in object && 'constructor' in other && !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n      result = false;\n    }\n  }\n  stack['delete'](object);\n  stack['delete'](other);\n  return result;\n}\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function (object) {\n  if (object == null) {\n    return [];\n  }\n  object = Object(object);\n  return arrayFilter(nativeGetSymbols(object), function (symbol) {\n    return propertyIsEnumerable.call(object, symbol);\n  });\n};\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise && getTag(Promise.resolve()) != promiseTag || Set && getTag(new Set()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {\n  getTag = function getTag(value) {\n    var result = baseGetTag(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : '';\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString:\n          return dataViewTag;\n        case mapCtorString:\n          return mapTag;\n        case promiseCtorString:\n          return promiseTag;\n        case setCtorString:\n          return setTag;\n        case weakMapCtorString:\n          return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length && (typeof value == 'number' || reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);\n  return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean' ? value !== '__proto__' : value === null;\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && maskSrcKey in func;\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = typeof Ctor == 'function' && Ctor.prototype || objectProto;\n\n  return value === proto;\n}\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return func + '';\n    } catch (e) {}\n  }\n  return '';\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || value !== value && other !== other;\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function () {\n  return arguments;\n}()) ? baseIsArguments : function (value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');\n};\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n  return baseIsEqual(value, other);\n}\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);\n  return value != null && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) == 'object';\n}\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\n/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = isEqual;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(4)(module)))\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar g;\n\n// This works in non-strict mode\ng = function () {\n\treturn this;\n}();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\n} catch (e) {\n\t// This works if the window reference is available\n\tif ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = function (module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function () {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function get() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function get() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n\n/***/ })\n/******/ ]);\n});"]}