{"version":3,"file":"_isLaziable-BEizACux.js","sources":["../../../node_modules/lodash/_metaMap.js","../../../node_modules/lodash/_baseLodash.js","../../../node_modules/lodash/_LazyWrapper.js","../../../node_modules/lodash/noop.js","../../../node_modules/lodash/_getData.js","../../../node_modules/lodash/_realNames.js","../../../node_modules/lodash/_getFuncName.js","../../../node_modules/lodash/_LodashWrapper.js","../../../node_modules/lodash/_wrapperClone.js","../../../node_modules/lodash/wrapperLodash.js","../../../node_modules/lodash/_isLaziable.js"],"sourcesContent":["var WeakMap = require('./_WeakMap');\n\n/** Used to store function metadata. */\nvar metaMap = WeakMap && new WeakMap;\n\nmodule.exports = metaMap;\n","/**\n * The function whose prototype chain sequence wrappers inherit from.\n *\n * @private\n */\nfunction baseLodash() {\n  // No operation performed.\n}\n\nmodule.exports = baseLodash;\n","var baseCreate = require('./_baseCreate'),\n    baseLodash = require('./_baseLodash');\n\n/** Used as references for the maximum length and index of an array. */\nvar MAX_ARRAY_LENGTH = 4294967295;\n\n/**\n * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.\n *\n * @private\n * @constructor\n * @param {*} value The value to wrap.\n */\nfunction LazyWrapper(value) {\n  this.__wrapped__ = value;\n  this.__actions__ = [];\n  this.__dir__ = 1;\n  this.__filtered__ = false;\n  this.__iteratees__ = [];\n  this.__takeCount__ = MAX_ARRAY_LENGTH;\n  this.__views__ = [];\n}\n\n// Ensure `LazyWrapper` is an instance of `baseLodash`.\nLazyWrapper.prototype = baseCreate(baseLodash.prototype);\nLazyWrapper.prototype.constructor = LazyWrapper;\n\nmodule.exports = LazyWrapper;\n","/**\n * This method returns `undefined`.\n *\n * @static\n * @memberOf _\n * @since 2.3.0\n * @category Util\n * @example\n *\n * _.times(2, _.noop);\n * // => [undefined, undefined]\n */\nfunction noop() {\n  // No operation performed.\n}\n\nmodule.exports = noop;\n","var metaMap = require('./_metaMap'),\n    noop = require('./noop');\n\n/**\n * Gets metadata for `func`.\n *\n * @private\n * @param {Function} func The function to query.\n * @returns {*} Returns the metadata for `func`.\n */\nvar getData = !metaMap ? noop : function(func) {\n  return metaMap.get(func);\n};\n\nmodule.exports = getData;\n","/** Used to lookup unminified function names. */\nvar realNames = {};\n\nmodule.exports = realNames;\n","var realNames = require('./_realNames');\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 * Gets the name of `func`.\n *\n * @private\n * @param {Function} func The function to query.\n * @returns {string} Returns the function name.\n */\nfunction getFuncName(func) {\n  var result = (func.name + ''),\n      array = realNames[result],\n      length = hasOwnProperty.call(realNames, result) ? array.length : 0;\n\n  while (length--) {\n    var data = array[length],\n        otherFunc = data.func;\n    if (otherFunc == null || otherFunc == func) {\n      return data.name;\n    }\n  }\n  return result;\n}\n\nmodule.exports = getFuncName;\n","var baseCreate = require('./_baseCreate'),\n    baseLodash = require('./_baseLodash');\n\n/**\n * The base constructor for creating `lodash` wrapper objects.\n *\n * @private\n * @param {*} value The value to wrap.\n * @param {boolean} [chainAll] Enable explicit method chain sequences.\n */\nfunction LodashWrapper(value, chainAll) {\n  this.__wrapped__ = value;\n  this.__actions__ = [];\n  this.__chain__ = !!chainAll;\n  this.__index__ = 0;\n  this.__values__ = undefined;\n}\n\nLodashWrapper.prototype = baseCreate(baseLodash.prototype);\nLodashWrapper.prototype.constructor = LodashWrapper;\n\nmodule.exports = LodashWrapper;\n","var LazyWrapper = require('./_LazyWrapper'),\n    LodashWrapper = require('./_LodashWrapper'),\n    copyArray = require('./_copyArray');\n\n/**\n * Creates a clone of `wrapper`.\n *\n * @private\n * @param {Object} wrapper The wrapper to clone.\n * @returns {Object} Returns the cloned wrapper.\n */\nfunction wrapperClone(wrapper) {\n  if (wrapper instanceof LazyWrapper) {\n    return wrapper.clone();\n  }\n  var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);\n  result.__actions__ = copyArray(wrapper.__actions__);\n  result.__index__  = wrapper.__index__;\n  result.__values__ = wrapper.__values__;\n  return result;\n}\n\nmodule.exports = wrapperClone;\n","var LazyWrapper = require('./_LazyWrapper'),\n    LodashWrapper = require('./_LodashWrapper'),\n    baseLodash = require('./_baseLodash'),\n    isArray = require('./isArray'),\n    isObjectLike = require('./isObjectLike'),\n    wrapperClone = require('./_wrapperClone');\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 * Creates a `lodash` object which wraps `value` to enable implicit method\n * chain sequences. Methods that operate on and return arrays, collections,\n * and functions can be chained together. Methods that retrieve a single value\n * or may return a primitive value will automatically end the chain sequence\n * and return the unwrapped value. Otherwise, the value must be unwrapped\n * with `_#value`.\n *\n * Explicit chain sequences, which must be unwrapped with `_#value`, may be\n * enabled using `_.chain`.\n *\n * The execution of chained methods is lazy, that is, it's deferred until\n * `_#value` is implicitly or explicitly called.\n *\n * Lazy evaluation allows several methods to support shortcut fusion.\n * Shortcut fusion is an optimization to merge iteratee calls; this avoids\n * the creation of intermediate arrays and can greatly reduce the number of\n * iteratee executions. Sections of a chain sequence qualify for shortcut\n * fusion if the section is applied to an array and iteratees accept only\n * one argument. The heuristic for whether a section qualifies for shortcut\n * fusion is subject to change.\n *\n * Chaining is supported in custom builds as long as the `_#value` method is\n * directly or indirectly included in the build.\n *\n * In addition to lodash methods, wrappers have `Array` and `String` methods.\n *\n * The wrapper `Array` methods are:\n * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`\n *\n * The wrapper `String` methods are:\n * `replace` and `split`\n *\n * The wrapper methods that support shortcut fusion are:\n * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,\n * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,\n * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`\n *\n * The chainable wrapper methods are:\n * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,\n * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,\n * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,\n * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,\n * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,\n * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,\n * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,\n * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,\n * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,\n * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,\n * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,\n * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,\n * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,\n * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,\n * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,\n * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,\n * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,\n * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,\n * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,\n * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,\n * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,\n * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,\n * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,\n * `zipObject`, `zipObjectDeep`, and `zipWith`\n *\n * The wrapper methods that are **not** chainable by default are:\n * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,\n * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,\n * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,\n * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,\n * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,\n * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,\n * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,\n * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,\n * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,\n * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,\n * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,\n * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,\n * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,\n * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,\n * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,\n * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,\n * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,\n * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,\n * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,\n * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,\n * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,\n * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,\n * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,\n * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,\n * `upperFirst`, `value`, and `words`\n *\n * @name _\n * @constructor\n * @category Seq\n * @param {*} value The value to wrap in a `lodash` instance.\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * function square(n) {\n *   return n * n;\n * }\n *\n * var wrapped = _([1, 2, 3]);\n *\n * // Returns an unwrapped value.\n * wrapped.reduce(_.add);\n * // => 6\n *\n * // Returns a wrapped value.\n * var squares = wrapped.map(square);\n *\n * _.isArray(squares);\n * // => false\n *\n * _.isArray(squares.value());\n * // => true\n */\nfunction lodash(value) {\n  if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {\n    if (value instanceof LodashWrapper) {\n      return value;\n    }\n    if (hasOwnProperty.call(value, '__wrapped__')) {\n      return wrapperClone(value);\n    }\n  }\n  return new LodashWrapper(value);\n}\n\n// Ensure wrappers are instances of `baseLodash`.\nlodash.prototype = baseLodash.prototype;\nlodash.prototype.constructor = lodash;\n\nmodule.exports = lodash;\n","var LazyWrapper = require('./_LazyWrapper'),\n    getData = require('./_getData'),\n    getFuncName = require('./_getFuncName'),\n    lodash = require('./wrapperLodash');\n\n/**\n * Checks if `func` has a lazy counterpart.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` has a lazy counterpart,\n *  else `false`.\n */\nfunction isLaziable(func) {\n  var funcName = getFuncName(func),\n      other = lodash[funcName];\n\n  if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {\n    return false;\n  }\n  if (func === other) {\n    return true;\n  }\n  var data = getData(other);\n  return !!data && func === data[0];\n}\n\nmodule.exports = isLaziable;\n"],"names":["WeakMap","require$$0","metaMap","_metaMap","baseLodash","_baseLodash","baseCreate","require$$1","MAX_ARRAY_LENGTH","LazyWrapper","value","_LazyWrapper","noop","noop_1","getData","func","_getData","realNames","_realNames","objectProto","hasOwnProperty","getFuncName","result","array","length","data","otherFunc","_getFuncName","LodashWrapper","chainAll","_LodashWrapper","copyArray","require$$2","wrapperClone","wrapper","_wrapperClone","isArray","require$$3","isObjectLike","require$$4","require$$5","lodash","wrapperLodash","isLaziable","funcName","other","_isLaziable"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10]}