{"version":3,"sources":["webpack:////build/source/node_modules/lodash/iteratee.js","webpack:////build/source/node_modules/lodash/fp/_baseConvert.js","webpack:////build/source/node_modules/lodash/fp/_util.js","webpack:////build/source/node_modules/lodash/clone.js","webpack:////build/source/node_modules/lodash/toPath.js","webpack:////build/source/node_modules/@gitlab/ui/dist/utils/data_utils.js","webpack:////build/source/node_modules/lodash/fp/_mapping.js","webpack:////build/source/node_modules/lodash/curry.js","webpack:////build/source/node_modules/lodash/rearg.js","webpack:////build/source/node_modules/lodash/isWeakMap.js","webpack:////build/source/node_modules/lodash/fp/curry.js","webpack:////build/source/node_modules/lodash/fp/placeholder.js","webpack:////build/source/node_modules/lodash/fp/convert.js","webpack:////build/source/node_modules/lodash/ary.js"],"names":["baseClone","baseIteratee","module","exports","func","mapping","fallbackHolder","push","Array","prototype","baseAry","n","a","b","cloneArray","array","length","result","wrapImmutable","cloner","arguments","args","apply","undefined","baseConvert","util","name","options","isLib","isObj","Object","TypeError","config","cap","curry","fixed","immutable","rearg","defaultHolder","forceCurry","forceFixed","forceRearg","pristine","runInContext","helpers","ary","assign","clone","forEach","isArray","isError","isFunction","isWeakMap","iteratee","keys","toInteger","toPath","each","aryMethodKeys","aryMethod","wrappers","castArray","value","arity","mixin","source","this","pairs","key","pair","nthArg","indexes","context","castCap","iterateeRearg","overArg","baseArity","iterateeAry","castFixed","skipFixed","data","methodSpread","start","lastIndex","otherArgs","slice","flatSpread","castRearg","skipRearg","methodRearg","aryRearg","cloneByPath","object","path","index","nested","createConverter","realName","aliasToReal","methodName","remap","oldOptions","newUtil","newFunc","newOptions","transform","wrap","placeholder","wrapped","wrapper","mutate","createCloner","set","aryKey","otherName","afterRearg","castCurry","convert","_","realToAlias","alias","arrayMap","copyArray","isSymbol","stringToPath","toKey","toString","intersperse","separator","items","head","rest","separatorFactory","flatMap","item","insert","newItem","hasOwnProperty","call","createWrap","guard","flatRest","getTag","isObjectLike"],"mappings":"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","file":"36.e76be504.chunk.js","sourcesContent":["var baseClone = require('./_baseClone'),\n    baseIteratee = require('./_baseIteratee');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1;\n\n/**\n * Creates a function that invokes `func` with the arguments of the created\n * function. If `func` is a property name, the created function returns the\n * property value for a given element. If `func` is an array or object, the\n * created function returns `true` for elements that contain the equivalent\n * source properties, otherwise it returns `false`.\n *\n * @static\n * @since 4.0.0\n * @memberOf _\n * @category Util\n * @param {*} [func=_.identity] The value to convert to a callback.\n * @returns {Function} Returns the callback.\n * @example\n *\n * var users = [\n *   { 'user': 'barney', 'age': 36, 'active': true },\n *   { 'user': 'fred',   'age': 40, 'active': false }\n * ];\n *\n * // The `_.matches` iteratee shorthand.\n * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));\n * // => [{ 'user': 'barney', 'age': 36, 'active': true }]\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.filter(users, _.iteratee(['user', 'fred']));\n * // => [{ 'user': 'fred', 'age': 40 }]\n *\n * // The `_.property` iteratee shorthand.\n * _.map(users, _.iteratee('user'));\n * // => ['barney', 'fred']\n *\n * // Create custom iteratee shorthands.\n * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {\n *   return !_.isRegExp(func) ? iteratee(func) : function(string) {\n *     return func.test(string);\n *   };\n * });\n *\n * _.filter(['abc', 'def'], /ef/);\n * // => ['def']\n */\nfunction iteratee(func) {\n  return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));\n}\n\nmodule.exports = iteratee;\n","var mapping = require('./_mapping'),\n    fallbackHolder = require('./placeholder');\n\n/** Built-in value reference. */\nvar push = Array.prototype.push;\n\n/**\n * Creates a function, with an arity of `n`, that invokes `func` with the\n * arguments it receives.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {number} n The arity of the new function.\n * @returns {Function} Returns the new function.\n */\nfunction baseArity(func, n) {\n  return n == 2\n    ? function(a, b) { return func.apply(undefined, arguments); }\n    : function(a) { return func.apply(undefined, arguments); };\n}\n\n/**\n * Creates a function that invokes `func`, with up to `n` arguments, ignoring\n * any additional arguments.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @param {number} n The arity cap.\n * @returns {Function} Returns the new function.\n */\nfunction baseAry(func, n) {\n  return n == 2\n    ? function(a, b) { return func(a, b); }\n    : function(a) { return func(a); };\n}\n\n/**\n * Creates a clone of `array`.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the cloned array.\n */\nfunction cloneArray(array) {\n  var length = array ? array.length : 0,\n      result = Array(length);\n\n  while (length--) {\n    result[length] = array[length];\n  }\n  return result;\n}\n\n/**\n * Creates a function that clones a given object using the assignment `func`.\n *\n * @private\n * @param {Function} func The assignment function.\n * @returns {Function} Returns the new cloner function.\n */\nfunction createCloner(func) {\n  return function(object) {\n    return func({}, object);\n  };\n}\n\n/**\n * A specialized version of `_.spread` which flattens the spread array into\n * the arguments of the invoked `func`.\n *\n * @private\n * @param {Function} func The function to spread arguments over.\n * @param {number} start The start position of the spread.\n * @returns {Function} Returns the new function.\n */\nfunction flatSpread(func, start) {\n  return function() {\n    var length = arguments.length,\n        lastIndex = length - 1,\n        args = Array(length);\n\n    while (length--) {\n      args[length] = arguments[length];\n    }\n    var array = args[start],\n        otherArgs = args.slice(0, start);\n\n    if (array) {\n      push.apply(otherArgs, array);\n    }\n    if (start != lastIndex) {\n      push.apply(otherArgs, args.slice(start + 1));\n    }\n    return func.apply(this, otherArgs);\n  };\n}\n\n/**\n * Creates a function that wraps `func` and uses `cloner` to clone the first\n * argument it receives.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} cloner The function to clone arguments.\n * @returns {Function} Returns the new immutable function.\n */\nfunction wrapImmutable(func, cloner) {\n  return function() {\n    var length = arguments.length;\n    if (!length) {\n      return;\n    }\n    var args = Array(length);\n    while (length--) {\n      args[length] = arguments[length];\n    }\n    var result = args[0] = cloner.apply(undefined, args);\n    func.apply(undefined, args);\n    return result;\n  };\n}\n\n/**\n * The base implementation of `convert` which accepts a `util` object of methods\n * required to perform conversions.\n *\n * @param {Object} util The util object.\n * @param {string} name The name of the function to convert.\n * @param {Function} func The function to convert.\n * @param {Object} [options] The options object.\n * @param {boolean} [options.cap=true] Specify capping iteratee arguments.\n * @param {boolean} [options.curry=true] Specify currying.\n * @param {boolean} [options.fixed=true] Specify fixed arity.\n * @param {boolean} [options.immutable=true] Specify immutable operations.\n * @param {boolean} [options.rearg=true] Specify rearranging arguments.\n * @returns {Function|Object} Returns the converted function or object.\n */\nfunction baseConvert(util, name, func, options) {\n  var isLib = typeof name == 'function',\n      isObj = name === Object(name);\n\n  if (isObj) {\n    options = func;\n    func = name;\n    name = undefined;\n  }\n  if (func == null) {\n    throw new TypeError;\n  }\n  options || (options = {});\n\n  var config = {\n    'cap': 'cap' in options ? options.cap : true,\n    'curry': 'curry' in options ? options.curry : true,\n    'fixed': 'fixed' in options ? options.fixed : true,\n    'immutable': 'immutable' in options ? options.immutable : true,\n    'rearg': 'rearg' in options ? options.rearg : true\n  };\n\n  var defaultHolder = isLib ? func : fallbackHolder,\n      forceCurry = ('curry' in options) && options.curry,\n      forceFixed = ('fixed' in options) && options.fixed,\n      forceRearg = ('rearg' in options) && options.rearg,\n      pristine = isLib ? func.runInContext() : undefined;\n\n  var helpers = isLib ? func : {\n    'ary': util.ary,\n    'assign': util.assign,\n    'clone': util.clone,\n    'curry': util.curry,\n    'forEach': util.forEach,\n    'isArray': util.isArray,\n    'isError': util.isError,\n    'isFunction': util.isFunction,\n    'isWeakMap': util.isWeakMap,\n    'iteratee': util.iteratee,\n    'keys': util.keys,\n    'rearg': util.rearg,\n    'toInteger': util.toInteger,\n    'toPath': util.toPath\n  };\n\n  var ary = helpers.ary,\n      assign = helpers.assign,\n      clone = helpers.clone,\n      curry = helpers.curry,\n      each = helpers.forEach,\n      isArray = helpers.isArray,\n      isError = helpers.isError,\n      isFunction = helpers.isFunction,\n      isWeakMap = helpers.isWeakMap,\n      keys = helpers.keys,\n      rearg = helpers.rearg,\n      toInteger = helpers.toInteger,\n      toPath = helpers.toPath;\n\n  var aryMethodKeys = keys(mapping.aryMethod);\n\n  var wrappers = {\n    'castArray': function(castArray) {\n      return function() {\n        var value = arguments[0];\n        return isArray(value)\n          ? castArray(cloneArray(value))\n          : castArray.apply(undefined, arguments);\n      };\n    },\n    'iteratee': function(iteratee) {\n      return function() {\n        var func = arguments[0],\n            arity = arguments[1],\n            result = iteratee(func, arity),\n            length = result.length;\n\n        if (config.cap && typeof arity == 'number') {\n          arity = arity > 2 ? (arity - 2) : 1;\n          return (length && length <= arity) ? result : baseAry(result, arity);\n        }\n        return result;\n      };\n    },\n    'mixin': function(mixin) {\n      return function(source) {\n        var func = this;\n        if (!isFunction(func)) {\n          return mixin(func, Object(source));\n        }\n        var pairs = [];\n        each(keys(source), function(key) {\n          if (isFunction(source[key])) {\n            pairs.push([key, func.prototype[key]]);\n          }\n        });\n\n        mixin(func, Object(source));\n\n        each(pairs, function(pair) {\n          var value = pair[1];\n          if (isFunction(value)) {\n            func.prototype[pair[0]] = value;\n          } else {\n            delete func.prototype[pair[0]];\n          }\n        });\n        return func;\n      };\n    },\n    'nthArg': function(nthArg) {\n      return function(n) {\n        var arity = n < 0 ? 1 : (toInteger(n) + 1);\n        return curry(nthArg(n), arity);\n      };\n    },\n    'rearg': function(rearg) {\n      return function(func, indexes) {\n        var arity = indexes ? indexes.length : 0;\n        return curry(rearg(func, indexes), arity);\n      };\n    },\n    'runInContext': function(runInContext) {\n      return function(context) {\n        return baseConvert(util, runInContext(context), options);\n      };\n    }\n  };\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * Casts `func` to a function with an arity capped iteratee if needed.\n   *\n   * @private\n   * @param {string} name The name of the function to inspect.\n   * @param {Function} func The function to inspect.\n   * @returns {Function} Returns the cast function.\n   */\n  function castCap(name, func) {\n    if (config.cap) {\n      var indexes = mapping.iterateeRearg[name];\n      if (indexes) {\n        return iterateeRearg(func, indexes);\n      }\n      var n = !isLib && mapping.iterateeAry[name];\n      if (n) {\n        return iterateeAry(func, n);\n      }\n    }\n    return func;\n  }\n\n  /**\n   * Casts `func` to a curried function if needed.\n   *\n   * @private\n   * @param {string} name The name of the function to inspect.\n   * @param {Function} func The function to inspect.\n   * @param {number} n The arity of `func`.\n   * @returns {Function} Returns the cast function.\n   */\n  function castCurry(name, func, n) {\n    return (forceCurry || (config.curry && n > 1))\n      ? curry(func, n)\n      : func;\n  }\n\n  /**\n   * Casts `func` to a fixed arity function if needed.\n   *\n   * @private\n   * @param {string} name The name of the function to inspect.\n   * @param {Function} func The function to inspect.\n   * @param {number} n The arity cap.\n   * @returns {Function} Returns the cast function.\n   */\n  function castFixed(name, func, n) {\n    if (config.fixed && (forceFixed || !mapping.skipFixed[name])) {\n      var data = mapping.methodSpread[name],\n          start = data && data.start;\n\n      return start  === undefined ? ary(func, n) : flatSpread(func, start);\n    }\n    return func;\n  }\n\n  /**\n   * Casts `func` to an rearged function if needed.\n   *\n   * @private\n   * @param {string} name The name of the function to inspect.\n   * @param {Function} func The function to inspect.\n   * @param {number} n The arity of `func`.\n   * @returns {Function} Returns the cast function.\n   */\n  function castRearg(name, func, n) {\n    return (config.rearg && n > 1 && (forceRearg || !mapping.skipRearg[name]))\n      ? rearg(func, mapping.methodRearg[name] || mapping.aryRearg[n])\n      : func;\n  }\n\n  /**\n   * Creates a clone of `object` by `path`.\n   *\n   * @private\n   * @param {Object} object The object to clone.\n   * @param {Array|string} path The path to clone by.\n   * @returns {Object} Returns the cloned object.\n   */\n  function cloneByPath(object, path) {\n    path = toPath(path);\n\n    var index = -1,\n        length = path.length,\n        lastIndex = length - 1,\n        result = clone(Object(object)),\n        nested = result;\n\n    while (nested != null && ++index < length) {\n      var key = path[index],\n          value = nested[key];\n\n      if (value != null &&\n          !(isFunction(value) || isError(value) || isWeakMap(value))) {\n        nested[key] = clone(index == lastIndex ? value : Object(value));\n      }\n      nested = nested[key];\n    }\n    return result;\n  }\n\n  /**\n   * Converts `lodash` to an immutable auto-curried iteratee-first data-last\n   * version with conversion `options` applied.\n   *\n   * @param {Object} [options] The options object. See `baseConvert` for more details.\n   * @returns {Function} Returns the converted `lodash`.\n   */\n  function convertLib(options) {\n    return _.runInContext.convert(options)(undefined);\n  }\n\n  /**\n   * Create a converter function for `func` of `name`.\n   *\n   * @param {string} name The name of the function to convert.\n   * @param {Function} func The function to convert.\n   * @returns {Function} Returns the new converter function.\n   */\n  function createConverter(name, func) {\n    var realName = mapping.aliasToReal[name] || name,\n        methodName = mapping.remap[realName] || realName,\n        oldOptions = options;\n\n    return function(options) {\n      var newUtil = isLib ? pristine : helpers,\n          newFunc = isLib ? pristine[methodName] : func,\n          newOptions = assign(assign({}, oldOptions), options);\n\n      return baseConvert(newUtil, realName, newFunc, newOptions);\n    };\n  }\n\n  /**\n   * Creates a function that wraps `func` to invoke its iteratee, with up to `n`\n   * arguments, ignoring any additional arguments.\n   *\n   * @private\n   * @param {Function} func The function to cap iteratee arguments for.\n   * @param {number} n The arity cap.\n   * @returns {Function} Returns the new function.\n   */\n  function iterateeAry(func, n) {\n    return overArg(func, function(func) {\n      return typeof func == 'function' ? baseAry(func, n) : func;\n    });\n  }\n\n  /**\n   * Creates a function that wraps `func` to invoke its iteratee with arguments\n   * arranged according to the specified `indexes` where the argument value at\n   * the first index is provided as the first argument, the argument value at\n   * the second index is provided as the second argument, and so on.\n   *\n   * @private\n   * @param {Function} func The function to rearrange iteratee arguments for.\n   * @param {number[]} indexes The arranged argument indexes.\n   * @returns {Function} Returns the new function.\n   */\n  function iterateeRearg(func, indexes) {\n    return overArg(func, function(func) {\n      var n = indexes.length;\n      return baseArity(rearg(baseAry(func, n), indexes), n);\n    });\n  }\n\n  /**\n   * Creates a function that invokes `func` with its first 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   */\n  function overArg(func, transform) {\n    return function() {\n      var length = arguments.length;\n      if (!length) {\n        return func();\n      }\n      var args = Array(length);\n      while (length--) {\n        args[length] = arguments[length];\n      }\n      var index = config.rearg ? 0 : (length - 1);\n      args[index] = transform(args[index]);\n      return func.apply(undefined, args);\n    };\n  }\n\n  /**\n   * Creates a function that wraps `func` and applys the conversions\n   * rules by `name`.\n   *\n   * @private\n   * @param {string} name The name of the function to wrap.\n   * @param {Function} func The function to wrap.\n   * @returns {Function} Returns the converted function.\n   */\n  function wrap(name, func, placeholder) {\n    var result,\n        realName = mapping.aliasToReal[name] || name,\n        wrapped = func,\n        wrapper = wrappers[realName];\n\n    if (wrapper) {\n      wrapped = wrapper(func);\n    }\n    else if (config.immutable) {\n      if (mapping.mutate.array[realName]) {\n        wrapped = wrapImmutable(func, cloneArray);\n      }\n      else if (mapping.mutate.object[realName]) {\n        wrapped = wrapImmutable(func, createCloner(func));\n      }\n      else if (mapping.mutate.set[realName]) {\n        wrapped = wrapImmutable(func, cloneByPath);\n      }\n    }\n    each(aryMethodKeys, function(aryKey) {\n      each(mapping.aryMethod[aryKey], function(otherName) {\n        if (realName == otherName) {\n          var data = mapping.methodSpread[realName],\n              afterRearg = data && data.afterRearg;\n\n          result = afterRearg\n            ? castFixed(realName, castRearg(realName, wrapped, aryKey), aryKey)\n            : castRearg(realName, castFixed(realName, wrapped, aryKey), aryKey);\n\n          result = castCap(realName, result);\n          result = castCurry(realName, result, aryKey);\n          return false;\n        }\n      });\n      return !result;\n    });\n\n    result || (result = wrapped);\n    if (result == func) {\n      result = forceCurry ? curry(result, 1) : function() {\n        return func.apply(this, arguments);\n      };\n    }\n    result.convert = createConverter(realName, func);\n    result.placeholder = func.placeholder = placeholder;\n\n    return result;\n  }\n\n  /*--------------------------------------------------------------------------*/\n\n  if (!isObj) {\n    return wrap(name, func, defaultHolder);\n  }\n  var _ = func;\n\n  // Convert methods by ary cap.\n  var pairs = [];\n  each(aryMethodKeys, function(aryKey) {\n    each(mapping.aryMethod[aryKey], function(key) {\n      var func = _[mapping.remap[key] || key];\n      if (func) {\n        pairs.push([key, wrap(key, func, _)]);\n      }\n    });\n  });\n\n  // Convert remaining methods.\n  each(keys(_), function(key) {\n    var func = _[key];\n    if (typeof func == 'function') {\n      var length = pairs.length;\n      while (length--) {\n        if (pairs[length][0] == key) {\n          return;\n        }\n      }\n      func.convert = createConverter(key, func);\n      pairs.push([key, func]);\n    }\n  });\n\n  // Assign to `_` leaving `_.prototype` unchanged to allow chaining.\n  each(pairs, function(pair) {\n    _[pair[0]] = pair[1];\n  });\n\n  _.convert = convertLib;\n  _.placeholder = _;\n\n  // Assign aliases.\n  each(keys(_), function(key) {\n    each(mapping.realToAlias[key] || [], function(alias) {\n      _[alias] = _[key];\n    });\n  });\n\n  return _;\n}\n\nmodule.exports = baseConvert;\n","module.exports = {\n  'ary': require('../ary'),\n  'assign': require('../_baseAssign'),\n  'clone': require('../clone'),\n  'curry': require('../curry'),\n  'forEach': require('../_arrayEach'),\n  'isArray': require('../isArray'),\n  'isError': require('../isError'),\n  'isFunction': require('../isFunction'),\n  'isWeakMap': require('../isWeakMap'),\n  'iteratee': require('../iteratee'),\n  'keys': require('../_baseKeys'),\n  'rearg': require('../rearg'),\n  'toInteger': require('../toInteger'),\n  'toPath': require('../toPath')\n};\n","var baseClone = require('./_baseClone');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_SYMBOLS_FLAG = 4;\n\n/**\n * Creates a shallow clone of `value`.\n *\n * **Note:** This method is loosely based on the\n * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)\n * and supports cloning arrays, array buffers, booleans, date objects, maps,\n * numbers, `Object` objects, regexes, sets, strings, symbols, and typed\n * arrays. The own enumerable properties of `arguments` objects are cloned\n * as plain objects. An empty object is returned for uncloneable values such\n * as error objects, functions, DOM nodes, and WeakMaps.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to clone.\n * @returns {*} Returns the cloned value.\n * @see _.cloneDeep\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var shallow = _.clone(objects);\n * console.log(shallow[0] === objects[0]);\n * // => true\n */\nfunction clone(value) {\n  return baseClone(value, CLONE_SYMBOLS_FLAG);\n}\n\nmodule.exports = clone;\n","var arrayMap = require('./_arrayMap'),\n    copyArray = require('./_copyArray'),\n    isArray = require('./isArray'),\n    isSymbol = require('./isSymbol'),\n    stringToPath = require('./_stringToPath'),\n    toKey = require('./_toKey'),\n    toString = require('./toString');\n\n/**\n * Converts `value` to a property path array.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {*} value The value to convert.\n * @returns {Array} Returns the new property path array.\n * @example\n *\n * _.toPath('a.b.c');\n * // => ['a', 'b', 'c']\n *\n * _.toPath('a[0].b.c');\n * // => ['a', '0', 'b', 'c']\n */\nfunction toPath(value) {\n  if (isArray(value)) {\n    return arrayMap(value, toKey);\n  }\n  return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));\n}\n\nmodule.exports = toPath;\n","import curry from 'lodash/fp/curry';\n\nconst getRepeatingValue = index => {\n  const values = [100, 500, 400, 200, 100, 800, 400, 500, 600, 300, 800, 900, 110, 700, 400, 300, 500, 300, 400, 600, 700];\n  return index < values.length ? values[index] : values[index % values.length];\n};\nconst generateTimeSeries = () => new Array(100).fill(0).map((el, i) => [new Date(2018, 0, i), getRepeatingValue(i)]);\n\n// takes an element and a list and `intersperses' that element between the elements of the list.\n// (',' ['a', 'b', 'c']) -> ['a', ',', 'b', ',', 'c']\nconst intersperse = curry((separator, items) => {\n  const [head, ...rest] = items;\n  const separatorFactory = typeof separator === 'function' ? separator : () => separator;\n  return [head, ...rest.flatMap(item => [separatorFactory(), item], rest)];\n});\n\n// inserts a value at a given index into an array\n// (1, 2, [1, 3, 4]) -> [1, 2, 3, 4]\nconst insert = curry((index, newItem, items) => [...items.slice(0, index), newItem, ...items.slice(index)]);\n\nexport { generateTimeSeries, insert, intersperse };\n","/** Used to map aliases to their real names. */\nexports.aliasToReal = {\n\n  // Lodash aliases.\n  'each': 'forEach',\n  'eachRight': 'forEachRight',\n  'entries': 'toPairs',\n  'entriesIn': 'toPairsIn',\n  'extend': 'assignIn',\n  'extendAll': 'assignInAll',\n  'extendAllWith': 'assignInAllWith',\n  'extendWith': 'assignInWith',\n  'first': 'head',\n\n  // Methods that are curried variants of others.\n  'conforms': 'conformsTo',\n  'matches': 'isMatch',\n  'property': 'get',\n\n  // Ramda aliases.\n  '__': 'placeholder',\n  'F': 'stubFalse',\n  'T': 'stubTrue',\n  'all': 'every',\n  'allPass': 'overEvery',\n  'always': 'constant',\n  'any': 'some',\n  'anyPass': 'overSome',\n  'apply': 'spread',\n  'assoc': 'set',\n  'assocPath': 'set',\n  'complement': 'negate',\n  'compose': 'flowRight',\n  'contains': 'includes',\n  'dissoc': 'unset',\n  'dissocPath': 'unset',\n  'dropLast': 'dropRight',\n  'dropLastWhile': 'dropRightWhile',\n  'equals': 'isEqual',\n  'identical': 'eq',\n  'indexBy': 'keyBy',\n  'init': 'initial',\n  'invertObj': 'invert',\n  'juxt': 'over',\n  'omitAll': 'omit',\n  'nAry': 'ary',\n  'path': 'get',\n  'pathEq': 'matchesProperty',\n  'pathOr': 'getOr',\n  'paths': 'at',\n  'pickAll': 'pick',\n  'pipe': 'flow',\n  'pluck': 'map',\n  'prop': 'get',\n  'propEq': 'matchesProperty',\n  'propOr': 'getOr',\n  'props': 'at',\n  'symmetricDifference': 'xor',\n  'symmetricDifferenceBy': 'xorBy',\n  'symmetricDifferenceWith': 'xorWith',\n  'takeLast': 'takeRight',\n  'takeLastWhile': 'takeRightWhile',\n  'unapply': 'rest',\n  'unnest': 'flatten',\n  'useWith': 'overArgs',\n  'where': 'conformsTo',\n  'whereEq': 'isMatch',\n  'zipObj': 'zipObject'\n};\n\n/** Used to map ary to method names. */\nexports.aryMethod = {\n  '1': [\n    'assignAll', 'assignInAll', 'attempt', 'castArray', 'ceil', 'create',\n    'curry', 'curryRight', 'defaultsAll', 'defaultsDeepAll', 'floor', 'flow',\n    'flowRight', 'fromPairs', 'invert', 'iteratee', 'memoize', 'method', 'mergeAll',\n    'methodOf', 'mixin', 'nthArg', 'over', 'overEvery', 'overSome','rest', 'reverse',\n    'round', 'runInContext', 'spread', 'template', 'trim', 'trimEnd', 'trimStart',\n    'uniqueId', 'words', 'zipAll'\n  ],\n  '2': [\n    'add', 'after', 'ary', 'assign', 'assignAllWith', 'assignIn', 'assignInAllWith',\n    'at', 'before', 'bind', 'bindAll', 'bindKey', 'chunk', 'cloneDeepWith',\n    'cloneWith', 'concat', 'conformsTo', 'countBy', 'curryN', 'curryRightN',\n    'debounce', 'defaults', 'defaultsDeep', 'defaultTo', 'delay', 'difference',\n    'divide', 'drop', 'dropRight', 'dropRightWhile', 'dropWhile', 'endsWith', 'eq',\n    'every', 'filter', 'find', 'findIndex', 'findKey', 'findLast', 'findLastIndex',\n    'findLastKey', 'flatMap', 'flatMapDeep', 'flattenDepth', 'forEach',\n    'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight', 'get',\n    'groupBy', 'gt', 'gte', 'has', 'hasIn', 'includes', 'indexOf', 'intersection',\n    'invertBy', 'invoke', 'invokeMap', 'isEqual', 'isMatch', 'join', 'keyBy',\n    'lastIndexOf', 'lt', 'lte', 'map', 'mapKeys', 'mapValues', 'matchesProperty',\n    'maxBy', 'meanBy', 'merge', 'mergeAllWith', 'minBy', 'multiply', 'nth', 'omit',\n    'omitBy', 'overArgs', 'pad', 'padEnd', 'padStart', 'parseInt', 'partial',\n    'partialRight', 'partition', 'pick', 'pickBy', 'propertyOf', 'pull', 'pullAll',\n    'pullAt', 'random', 'range', 'rangeRight', 'rearg', 'reject', 'remove',\n    'repeat', 'restFrom', 'result', 'sampleSize', 'some', 'sortBy', 'sortedIndex',\n    'sortedIndexOf', 'sortedLastIndex', 'sortedLastIndexOf', 'sortedUniqBy',\n    'split', 'spreadFrom', 'startsWith', 'subtract', 'sumBy', 'take', 'takeRight',\n    'takeRightWhile', 'takeWhile', 'tap', 'throttle', 'thru', 'times', 'trimChars',\n    'trimCharsEnd', 'trimCharsStart', 'truncate', 'union', 'uniqBy', 'uniqWith',\n    'unset', 'unzipWith', 'without', 'wrap', 'xor', 'zip', 'zipObject',\n    'zipObjectDeep'\n  ],\n  '3': [\n    'assignInWith', 'assignWith', 'clamp', 'differenceBy', 'differenceWith',\n    'findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom', 'getOr',\n    'includesFrom', 'indexOfFrom', 'inRange', 'intersectionBy', 'intersectionWith',\n    'invokeArgs', 'invokeArgsMap', 'isEqualWith', 'isMatchWith', 'flatMapDepth',\n    'lastIndexOfFrom', 'mergeWith', 'orderBy', 'padChars', 'padCharsEnd',\n    'padCharsStart', 'pullAllBy', 'pullAllWith', 'rangeStep', 'rangeStepRight',\n    'reduce', 'reduceRight', 'replace', 'set', 'slice', 'sortedIndexBy',\n    'sortedLastIndexBy', 'transform', 'unionBy', 'unionWith', 'update', 'xorBy',\n    'xorWith', 'zipWith'\n  ],\n  '4': [\n    'fill', 'setWith', 'updateWith'\n  ]\n};\n\n/** Used to map ary to rearg configs. */\nexports.aryRearg = {\n  '2': [1, 0],\n  '3': [2, 0, 1],\n  '4': [3, 2, 0, 1]\n};\n\n/** Used to map method names to their iteratee ary. */\nexports.iterateeAry = {\n  'dropRightWhile': 1,\n  'dropWhile': 1,\n  'every': 1,\n  'filter': 1,\n  'find': 1,\n  'findFrom': 1,\n  'findIndex': 1,\n  'findIndexFrom': 1,\n  'findKey': 1,\n  'findLast': 1,\n  'findLastFrom': 1,\n  'findLastIndex': 1,\n  'findLastIndexFrom': 1,\n  'findLastKey': 1,\n  'flatMap': 1,\n  'flatMapDeep': 1,\n  'flatMapDepth': 1,\n  'forEach': 1,\n  'forEachRight': 1,\n  'forIn': 1,\n  'forInRight': 1,\n  'forOwn': 1,\n  'forOwnRight': 1,\n  'map': 1,\n  'mapKeys': 1,\n  'mapValues': 1,\n  'partition': 1,\n  'reduce': 2,\n  'reduceRight': 2,\n  'reject': 1,\n  'remove': 1,\n  'some': 1,\n  'takeRightWhile': 1,\n  'takeWhile': 1,\n  'times': 1,\n  'transform': 2\n};\n\n/** Used to map method names to iteratee rearg configs. */\nexports.iterateeRearg = {\n  'mapKeys': [1],\n  'reduceRight': [1, 0]\n};\n\n/** Used to map method names to rearg configs. */\nexports.methodRearg = {\n  'assignInAllWith': [1, 0],\n  'assignInWith': [1, 2, 0],\n  'assignAllWith': [1, 0],\n  'assignWith': [1, 2, 0],\n  'differenceBy': [1, 2, 0],\n  'differenceWith': [1, 2, 0],\n  'getOr': [2, 1, 0],\n  'intersectionBy': [1, 2, 0],\n  'intersectionWith': [1, 2, 0],\n  'isEqualWith': [1, 2, 0],\n  'isMatchWith': [2, 1, 0],\n  'mergeAllWith': [1, 0],\n  'mergeWith': [1, 2, 0],\n  'padChars': [2, 1, 0],\n  'padCharsEnd': [2, 1, 0],\n  'padCharsStart': [2, 1, 0],\n  'pullAllBy': [2, 1, 0],\n  'pullAllWith': [2, 1, 0],\n  'rangeStep': [1, 2, 0],\n  'rangeStepRight': [1, 2, 0],\n  'setWith': [3, 1, 2, 0],\n  'sortedIndexBy': [2, 1, 0],\n  'sortedLastIndexBy': [2, 1, 0],\n  'unionBy': [1, 2, 0],\n  'unionWith': [1, 2, 0],\n  'updateWith': [3, 1, 2, 0],\n  'xorBy': [1, 2, 0],\n  'xorWith': [1, 2, 0],\n  'zipWith': [1, 2, 0]\n};\n\n/** Used to map method names to spread configs. */\nexports.methodSpread = {\n  'assignAll': { 'start': 0 },\n  'assignAllWith': { 'start': 0 },\n  'assignInAll': { 'start': 0 },\n  'assignInAllWith': { 'start': 0 },\n  'defaultsAll': { 'start': 0 },\n  'defaultsDeepAll': { 'start': 0 },\n  'invokeArgs': { 'start': 2 },\n  'invokeArgsMap': { 'start': 2 },\n  'mergeAll': { 'start': 0 },\n  'mergeAllWith': { 'start': 0 },\n  'partial': { 'start': 1 },\n  'partialRight': { 'start': 1 },\n  'without': { 'start': 1 },\n  'zipAll': { 'start': 0 }\n};\n\n/** Used to identify methods which mutate arrays or objects. */\nexports.mutate = {\n  'array': {\n    'fill': true,\n    'pull': true,\n    'pullAll': true,\n    'pullAllBy': true,\n    'pullAllWith': true,\n    'pullAt': true,\n    'remove': true,\n    'reverse': true\n  },\n  'object': {\n    'assign': true,\n    'assignAll': true,\n    'assignAllWith': true,\n    'assignIn': true,\n    'assignInAll': true,\n    'assignInAllWith': true,\n    'assignInWith': true,\n    'assignWith': true,\n    'defaults': true,\n    'defaultsAll': true,\n    'defaultsDeep': true,\n    'defaultsDeepAll': true,\n    'merge': true,\n    'mergeAll': true,\n    'mergeAllWith': true,\n    'mergeWith': true,\n  },\n  'set': {\n    'set': true,\n    'setWith': true,\n    'unset': true,\n    'update': true,\n    'updateWith': true\n  }\n};\n\n/** Used to map real names to their aliases. */\nexports.realToAlias = (function() {\n  var hasOwnProperty = Object.prototype.hasOwnProperty,\n      object = exports.aliasToReal,\n      result = {};\n\n  for (var key in object) {\n    var value = object[key];\n    if (hasOwnProperty.call(result, value)) {\n      result[value].push(key);\n    } else {\n      result[value] = [key];\n    }\n  }\n  return result;\n}());\n\n/** Used to map method names to other names. */\nexports.remap = {\n  'assignAll': 'assign',\n  'assignAllWith': 'assignWith',\n  'assignInAll': 'assignIn',\n  'assignInAllWith': 'assignInWith',\n  'curryN': 'curry',\n  'curryRightN': 'curryRight',\n  'defaultsAll': 'defaults',\n  'defaultsDeepAll': 'defaultsDeep',\n  'findFrom': 'find',\n  'findIndexFrom': 'findIndex',\n  'findLastFrom': 'findLast',\n  'findLastIndexFrom': 'findLastIndex',\n  'getOr': 'get',\n  'includesFrom': 'includes',\n  'indexOfFrom': 'indexOf',\n  'invokeArgs': 'invoke',\n  'invokeArgsMap': 'invokeMap',\n  'lastIndexOfFrom': 'lastIndexOf',\n  'mergeAll': 'merge',\n  'mergeAllWith': 'mergeWith',\n  'padChars': 'pad',\n  'padCharsEnd': 'padEnd',\n  'padCharsStart': 'padStart',\n  'propertyOf': 'get',\n  'rangeStep': 'range',\n  'rangeStepRight': 'rangeRight',\n  'restFrom': 'rest',\n  'spreadFrom': 'spread',\n  'trimChars': 'trim',\n  'trimCharsEnd': 'trimEnd',\n  'trimCharsStart': 'trimStart',\n  'zipAll': 'zip'\n};\n\n/** Used to track methods that skip fixing their arity. */\nexports.skipFixed = {\n  'castArray': true,\n  'flow': true,\n  'flowRight': true,\n  'iteratee': true,\n  'mixin': true,\n  'rearg': true,\n  'runInContext': true\n};\n\n/** Used to track methods that skip rearranging arguments. */\nexports.skipRearg = {\n  'add': true,\n  'assign': true,\n  'assignIn': true,\n  'bind': true,\n  'bindKey': true,\n  'concat': true,\n  'difference': true,\n  'divide': true,\n  'eq': true,\n  'gt': true,\n  'gte': true,\n  'isEqual': true,\n  'lt': true,\n  'lte': true,\n  'matchesProperty': true,\n  'merge': true,\n  'multiply': true,\n  'overArgs': true,\n  'partial': true,\n  'partialRight': true,\n  'propertyOf': true,\n  'random': true,\n  'range': true,\n  'rangeRight': true,\n  'subtract': true,\n  'zip': true,\n  'zipObject': true,\n  'zipObjectDeep': true\n};\n","var createWrap = require('./_createWrap');\n\n/** Used to compose bitmasks for function metadata. */\nvar WRAP_CURRY_FLAG = 8;\n\n/**\n * Creates a function that accepts arguments of `func` and either invokes\n * `func` returning its result, if at least `arity` number of arguments have\n * been provided, or returns a function that accepts the remaining `func`\n * arguments, and so on. The arity of `func` may be specified if `func.length`\n * is not sufficient.\n *\n * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,\n * may be used as a placeholder for provided arguments.\n *\n * **Note:** This method doesn't set the \"length\" property of curried functions.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Function\n * @param {Function} func The function to curry.\n * @param {number} [arity=func.length] The arity of `func`.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Function} Returns the new curried function.\n * @example\n *\n * var abc = function(a, b, c) {\n *   return [a, b, c];\n * };\n *\n * var curried = _.curry(abc);\n *\n * curried(1)(2)(3);\n * // => [1, 2, 3]\n *\n * curried(1, 2)(3);\n * // => [1, 2, 3]\n *\n * curried(1, 2, 3);\n * // => [1, 2, 3]\n *\n * // Curried with placeholders.\n * curried(1)(_, 3)(2);\n * // => [1, 2, 3]\n */\nfunction curry(func, arity, guard) {\n  arity = guard ? undefined : arity;\n  var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n  result.placeholder = curry.placeholder;\n  return result;\n}\n\n// Assign default placeholders.\ncurry.placeholder = {};\n\nmodule.exports = curry;\n","var createWrap = require('./_createWrap'),\n    flatRest = require('./_flatRest');\n\n/** Used to compose bitmasks for function metadata. */\nvar WRAP_REARG_FLAG = 256;\n\n/**\n * Creates a function that invokes `func` with arguments arranged according\n * to the specified `indexes` where the argument value at the first index is\n * provided as the first argument, the argument value at the second index is\n * provided as the second argument, and so on.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {Function} func The function to rearrange arguments for.\n * @param {...(number|number[])} indexes The arranged argument indexes.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var rearged = _.rearg(function(a, b, c) {\n *   return [a, b, c];\n * }, [2, 0, 1]);\n *\n * rearged('b', 'c', 'a')\n * // => ['a', 'b', 'c']\n */\nvar rearg = flatRest(function(func, indexes) {\n  return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);\n});\n\nmodule.exports = rearg;\n","var getTag = require('./_getTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar weakMapTag = '[object WeakMap]';\n\n/**\n * Checks if `value` is classified as a `WeakMap` object.\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 weak map, else `false`.\n * @example\n *\n * _.isWeakMap(new WeakMap);\n * // => true\n *\n * _.isWeakMap(new Map);\n * // => false\n */\nfunction isWeakMap(value) {\n  return isObjectLike(value) && getTag(value) == weakMapTag;\n}\n\nmodule.exports = isWeakMap;\n","var convert = require('./convert'),\n    func = convert('curry', require('../curry'));\n\nfunc.placeholder = require('./placeholder');\nmodule.exports = func;\n","/**\n * The default argument placeholder value for methods.\n *\n * @type {Object}\n */\nmodule.exports = {};\n","var baseConvert = require('./_baseConvert'),\n    util = require('./_util');\n\n/**\n * Converts `func` of `name` to an immutable auto-curried iteratee-first data-last\n * version with conversion `options` applied. If `name` is an object its methods\n * will be converted.\n *\n * @param {string} name The name of the function to wrap.\n * @param {Function} [func] The function to wrap.\n * @param {Object} [options] The options object. See `baseConvert` for more details.\n * @returns {Function|Object} Returns the converted function or object.\n */\nfunction convert(name, func, options) {\n  return baseConvert(util, name, func, options);\n}\n\nmodule.exports = convert;\n","var createWrap = require('./_createWrap');\n\n/** Used to compose bitmasks for function metadata. */\nvar WRAP_ARY_FLAG = 128;\n\n/**\n * Creates a function that invokes `func`, with up to `n` arguments,\n * ignoring any additional arguments.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {Function} func The function to cap arguments for.\n * @param {number} [n=func.length] The arity cap.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Function} Returns the new capped function.\n * @example\n *\n * _.map(['6', '8', '10'], _.ary(parseInt, 1));\n * // => [6, 8, 10]\n */\nfunction ary(func, n, guard) {\n  n = guard ? undefined : n;\n  n = (func && n == null) ? func.length : n;\n  return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);\n}\n\nmodule.exports = ary;\n"],"sourceRoot":""}