{"version":3,"file":"merge-DdOOoN5X.js","sources":["../../../node_modules/lodash/_assignMergeValue.js","../../../node_modules/lodash/_cloneBuffer.js","../../../node_modules/lodash/_cloneArrayBuffer.js","../../../node_modules/lodash/_cloneTypedArray.js","../../../node_modules/lodash/_initCloneObject.js","../../../node_modules/lodash/isArrayLikeObject.js","../../../node_modules/lodash/_safeGet.js","../../../node_modules/lodash/toPlainObject.js","../../../node_modules/lodash/_baseMergeDeep.js","../../../node_modules/lodash/_baseMerge.js","../../../node_modules/lodash/merge.js"],"sourcesContent":["var baseAssignValue = require('./_baseAssignValue'),\n    eq = require('./eq');\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n  if ((value !== undefined && !eq(object[key], value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nmodule.exports = assignMergeValue;\n","var root = require('./_root');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\nmodule.exports = cloneBuffer;\n","var Uint8Array = require('./_Uint8Array');\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\nmodule.exports = cloneArrayBuffer;\n","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nmodule.exports = cloneTypedArray;\n","var baseCreate = require('./_baseCreate'),\n    getPrototype = require('./_getPrototype'),\n    isPrototype = require('./_isPrototype');\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\nmodule.exports = initCloneObject;\n","var isArrayLike = require('./isArrayLike'),\n    isObjectLike = require('./isObjectLike');\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an 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 an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\nmodule.exports = isArrayLikeObject;\n","/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\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 safeGet(object, key) {\n  if (key === 'constructor' && typeof object[key] === 'function') {\n    return;\n  }\n\n  if (key == '__proto__') {\n    return;\n  }\n\n  return object[key];\n}\n\nmodule.exports = safeGet;\n","var copyObject = require('./_copyObject'),\n    keysIn = require('./keysIn');\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n  return copyObject(value, keysIn(value));\n}\n\nmodule.exports = toPlainObject;\n","var assignMergeValue = require('./_assignMergeValue'),\n    cloneBuffer = require('./_cloneBuffer'),\n    cloneTypedArray = require('./_cloneTypedArray'),\n    copyArray = require('./_copyArray'),\n    initCloneObject = require('./_initCloneObject'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isArrayLikeObject = require('./isArrayLikeObject'),\n    isBuffer = require('./isBuffer'),\n    isFunction = require('./isFunction'),\n    isObject = require('./isObject'),\n    isPlainObject = require('./isPlainObject'),\n    isTypedArray = require('./isTypedArray'),\n    safeGet = require('./_safeGet'),\n    toPlainObject = require('./toPlainObject');\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n  var objValue = safeGet(object, key),\n      srcValue = safeGet(source, key),\n      stacked = stack.get(srcValue);\n\n  if (stacked) {\n    assignMergeValue(object, key, stacked);\n    return;\n  }\n  var newValue = customizer\n    ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n    : undefined;\n\n  var isCommon = newValue === undefined;\n\n  if (isCommon) {\n    var isArr = isArray(srcValue),\n        isBuff = !isArr && isBuffer(srcValue),\n        isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n    newValue = srcValue;\n    if (isArr || isBuff || isTyped) {\n      if (isArray(objValue)) {\n        newValue = objValue;\n      }\n      else if (isArrayLikeObject(objValue)) {\n        newValue = copyArray(objValue);\n      }\n      else if (isBuff) {\n        isCommon = false;\n        newValue = cloneBuffer(srcValue, true);\n      }\n      else if (isTyped) {\n        isCommon = false;\n        newValue = cloneTypedArray(srcValue, true);\n      }\n      else {\n        newValue = [];\n      }\n    }\n    else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n      newValue = objValue;\n      if (isArguments(objValue)) {\n        newValue = toPlainObject(objValue);\n      }\n      else if (!isObject(objValue) || isFunction(objValue)) {\n        newValue = initCloneObject(srcValue);\n      }\n    }\n    else {\n      isCommon = false;\n    }\n  }\n  if (isCommon) {\n    // Recursively merge objects and arrays (susceptible to call stack limits).\n    stack.set(srcValue, newValue);\n    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n    stack['delete'](srcValue);\n  }\n  assignMergeValue(object, key, newValue);\n}\n\nmodule.exports = baseMergeDeep;\n","var Stack = require('./_Stack'),\n    assignMergeValue = require('./_assignMergeValue'),\n    baseFor = require('./_baseFor'),\n    baseMergeDeep = require('./_baseMergeDeep'),\n    isObject = require('./isObject'),\n    keysIn = require('./keysIn'),\n    safeGet = require('./_safeGet');\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n  if (object === source) {\n    return;\n  }\n  baseFor(source, function(srcValue, key) {\n    stack || (stack = new Stack);\n    if (isObject(srcValue)) {\n      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n    }\n    else {\n      var newValue = customizer\n        ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n        : undefined;\n\n      if (newValue === undefined) {\n        newValue = srcValue;\n      }\n      assignMergeValue(object, key, newValue);\n    }\n  }, keysIn);\n}\n\nmodule.exports = baseMerge;\n","var baseMerge = require('./_baseMerge'),\n    createAssigner = require('./_createAssigner');\n\n/**\n * This method is like `_.assign` except that it recursively merges own and\n * inherited enumerable string keyed properties of source objects into the\n * destination object. Source properties that resolve to `undefined` are\n * skipped if a destination value exists. Array and plain object properties\n * are merged recursively. Other objects and value types are overridden by\n * assignment. Source objects are applied from left to right. Subsequent\n * sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {\n *   'a': [{ 'b': 2 }, { 'd': 4 }]\n * };\n *\n * var other = {\n *   'a': [{ 'c': 3 }, { 'e': 5 }]\n * };\n *\n * _.merge(object, other);\n * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n */\nvar merge = createAssigner(function(object, source, srcIndex) {\n  baseMerge(object, source, srcIndex);\n});\n\nmodule.exports = merge;\n"],"names":["baseAssignValue","require$$0","eq","require$$1","assignMergeValue","object","key","value","_assignMergeValue","root","freeExports","exports","freeModule","module","moduleExports","Buffer","allocUnsafe","cloneBuffer","buffer","isDeep","length","result","Uint8Array","cloneArrayBuffer","arrayBuffer","_cloneArrayBuffer","cloneTypedArray","typedArray","_cloneTypedArray","baseCreate","getPrototype","isPrototype","require$$2","initCloneObject","_initCloneObject","isArrayLike","isObjectLike","isArrayLikeObject","isArrayLikeObject_1","safeGet","_safeGet","copyObject","keysIn","toPlainObject","toPlainObject_1","copyArray","require$$3","require$$4","isArguments","require$$5","isArray","require$$6","require$$7","isBuffer","require$$8","isFunction","require$$9","isObject","require$$10","isPlainObject","require$$11","isTypedArray","require$$12","require$$13","require$$14","baseMergeDeep","source","srcIndex","mergeFunc","customizer","stack","objValue","srcValue","stacked","newValue","isCommon","isArr","isBuff","isTyped","_baseMergeDeep","Stack","baseFor","baseMerge","_baseMerge","createAssigner","merge","merge_1"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10]}