@mattisvensson/strapi-plugin-webatlas 0.2.0 → 0.2.1

package/dist/_chunks/{index-DKdReNuu.mjs → index-BDU-lYsm.mjs}

@@ -4,13 +4,13 @@ import React__default, { useContext, useRef, useCallback, useDebugValue, useMemo
 import { ArrowLeft, Eye, EyeStriked, WarningCircle, Filter, CaretDown, Check } from "@strapi/icons";
 import { Link, Alert, Typography, Box, Flex, useCallbackRef, useComposedRefs, Field, Toggle, Checkbox, DatePicker, DateTimePicker, TextInput, SingleSelect, SingleSelectOption, JSONInput, NumberInput, Textarea, TimePicker, Popover, Button, MultiSelect, MultiSelectOption, Accordion } from "@strapi/design-system";
 import "react-dom/client";
-import { c as commonjsGlobal, g as getAugmentedNamespace, a as getDefaultExportFromCjs } from "./_commonjsHelpers-BxmBWJD2.mjs";
+import { c as commonjsGlobal, g as getAugmentedNamespace, a as getDefaultExportFromCjs, _ as _baseConvert, r as requirePlaceholder } from "./_baseConvert-C2SW1VHq.mjs";
 import { useLocation, useNavigate, NavLink } from "react-router-dom";
 import { useIntl } from "react-intl";
 import "@strapi/icons/symbols";
 import ReactDOM__default, { unstable_batchedUpdates as unstable_batchedUpdates$1 } from "react-dom";
 import { createGlobalStyle, styled } from "styled-components";
-import { _ as _extends$4, b as usePluginConfig, c as useAllContentTypes, t as transformToUrl, T as Tooltip } from "./index-C4lB5G1F.mjs";
+import { _ as _extends$4, b as usePluginConfig, c as useAllContentTypes, t as transformToUrl, T as Tooltip } from "./index-c7q9J79y.mjs";
 var freeGlobal$1 = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
 var _freeGlobal = freeGlobal$1;
 var freeGlobal = _freeGlobal;
@@ -2796,9 +2796,9 @@ var arrayPrefixGenerators = {
   }
 };
 var isArray$6 = Array.isArray;
-var push$1 = Array.prototype.push;
+var push = Array.prototype.push;
 var pushToArray = function(arr, valueOrArray) {
-  push$1.apply(arr, isArray$6(valueOrArray) ? valueOrArray : [valueOrArray]);
+  push.apply(arr, isArray$6(valueOrArray) ? valueOrArray : [valueOrArray]);
 };
 var toISO = Date.prototype.toISOString;
 var defaultFormat = formats$1["default"];
@@ -8518,836 +8518,6 @@ var reactHooksModule = function(_c) {
   };
 };
 var createApi = /* @__PURE__ */ buildCreateApi(coreModule(), reactHooksModule());
-var _mapping = {};
-(function(exports) {
-  exports.aliasToReal = {
-    // Lodash aliases.
-    "each": "forEach",
-    "eachRight": "forEachRight",
-    "entries": "toPairs",
-    "entriesIn": "toPairsIn",
-    "extend": "assignIn",
-    "extendAll": "assignInAll",
-    "extendAllWith": "assignInAllWith",
-    "extendWith": "assignInWith",
-    "first": "head",
-    // Methods that are curried variants of others.
-    "conforms": "conformsTo",
-    "matches": "isMatch",
-    "property": "get",
-    // Ramda aliases.
-    "__": "placeholder",
-    "F": "stubFalse",
-    "T": "stubTrue",
-    "all": "every",
-    "allPass": "overEvery",
-    "always": "constant",
-    "any": "some",
-    "anyPass": "overSome",
-    "apply": "spread",
-    "assoc": "set",
-    "assocPath": "set",
-    "complement": "negate",
-    "compose": "flowRight",
-    "contains": "includes",
-    "dissoc": "unset",
-    "dissocPath": "unset",
-    "dropLast": "dropRight",
-    "dropLastWhile": "dropRightWhile",
-    "equals": "isEqual",
-    "identical": "eq",
-    "indexBy": "keyBy",
-    "init": "initial",
-    "invertObj": "invert",
-    "juxt": "over",
-    "omitAll": "omit",
-    "nAry": "ary",
-    "path": "get",
-    "pathEq": "matchesProperty",
-    "pathOr": "getOr",
-    "paths": "at",
-    "pickAll": "pick",
-    "pipe": "flow",
-    "pluck": "map",
-    "prop": "get",
-    "propEq": "matchesProperty",
-    "propOr": "getOr",
-    "props": "at",
-    "symmetricDifference": "xor",
-    "symmetricDifferenceBy": "xorBy",
-    "symmetricDifferenceWith": "xorWith",
-    "takeLast": "takeRight",
-    "takeLastWhile": "takeRightWhile",
-    "unapply": "rest",
-    "unnest": "flatten",
-    "useWith": "overArgs",
-    "where": "conformsTo",
-    "whereEq": "isMatch",
-    "zipObj": "zipObject"
-  };
-  exports.aryMethod = {
-    "1": [
-      "assignAll",
-      "assignInAll",
-      "attempt",
-      "castArray",
-      "ceil",
-      "create",
-      "curry",
-      "curryRight",
-      "defaultsAll",
-      "defaultsDeepAll",
-      "floor",
-      "flow",
-      "flowRight",
-      "fromPairs",
-      "invert",
-      "iteratee",
-      "memoize",
-      "method",
-      "mergeAll",
-      "methodOf",
-      "mixin",
-      "nthArg",
-      "over",
-      "overEvery",
-      "overSome",
-      "rest",
-      "reverse",
-      "round",
-      "runInContext",
-      "spread",
-      "template",
-      "trim",
-      "trimEnd",
-      "trimStart",
-      "uniqueId",
-      "words",
-      "zipAll"
-    ],
-    "2": [
-      "add",
-      "after",
-      "ary",
-      "assign",
-      "assignAllWith",
-      "assignIn",
-      "assignInAllWith",
-      "at",
-      "before",
-      "bind",
-      "bindAll",
-      "bindKey",
-      "chunk",
-      "cloneDeepWith",
-      "cloneWith",
-      "concat",
-      "conformsTo",
-      "countBy",
-      "curryN",
-      "curryRightN",
-      "debounce",
-      "defaults",
-      "defaultsDeep",
-      "defaultTo",
-      "delay",
-      "difference",
-      "divide",
-      "drop",
-      "dropRight",
-      "dropRightWhile",
-      "dropWhile",
-      "endsWith",
-      "eq",
-      "every",
-      "filter",
-      "find",
-      "findIndex",
-      "findKey",
-      "findLast",
-      "findLastIndex",
-      "findLastKey",
-      "flatMap",
-      "flatMapDeep",
-      "flattenDepth",
-      "forEach",
-      "forEachRight",
-      "forIn",
-      "forInRight",
-      "forOwn",
-      "forOwnRight",
-      "get",
-      "groupBy",
-      "gt",
-      "gte",
-      "has",
-      "hasIn",
-      "includes",
-      "indexOf",
-      "intersection",
-      "invertBy",
-      "invoke",
-      "invokeMap",
-      "isEqual",
-      "isMatch",
-      "join",
-      "keyBy",
-      "lastIndexOf",
-      "lt",
-      "lte",
-      "map",
-      "mapKeys",
-      "mapValues",
-      "matchesProperty",
-      "maxBy",
-      "meanBy",
-      "merge",
-      "mergeAllWith",
-      "minBy",
-      "multiply",
-      "nth",
-      "omit",
-      "omitBy",
-      "overArgs",
-      "pad",
-      "padEnd",
-      "padStart",
-      "parseInt",
-      "partial",
-      "partialRight",
-      "partition",
-      "pick",
-      "pickBy",
-      "propertyOf",
-      "pull",
-      "pullAll",
-      "pullAt",
-      "random",
-      "range",
-      "rangeRight",
-      "rearg",
-      "reject",
-      "remove",
-      "repeat",
-      "restFrom",
-      "result",
-      "sampleSize",
-      "some",
-      "sortBy",
-      "sortedIndex",
-      "sortedIndexOf",
-      "sortedLastIndex",
-      "sortedLastIndexOf",
-      "sortedUniqBy",
-      "split",
-      "spreadFrom",
-      "startsWith",
-      "subtract",
-      "sumBy",
-      "take",
-      "takeRight",
-      "takeRightWhile",
-      "takeWhile",
-      "tap",
-      "throttle",
-      "thru",
-      "times",
-      "trimChars",
-      "trimCharsEnd",
-      "trimCharsStart",
-      "truncate",
-      "union",
-      "uniqBy",
-      "uniqWith",
-      "unset",
-      "unzipWith",
-      "without",
-      "wrap",
-      "xor",
-      "zip",
-      "zipObject",
-      "zipObjectDeep"
-    ],
-    "3": [
-      "assignInWith",
-      "assignWith",
-      "clamp",
-      "differenceBy",
-      "differenceWith",
-      "findFrom",
-      "findIndexFrom",
-      "findLastFrom",
-      "findLastIndexFrom",
-      "getOr",
-      "includesFrom",
-      "indexOfFrom",
-      "inRange",
-      "intersectionBy",
-      "intersectionWith",
-      "invokeArgs",
-      "invokeArgsMap",
-      "isEqualWith",
-      "isMatchWith",
-      "flatMapDepth",
-      "lastIndexOfFrom",
-      "mergeWith",
-      "orderBy",
-      "padChars",
-      "padCharsEnd",
-      "padCharsStart",
-      "pullAllBy",
-      "pullAllWith",
-      "rangeStep",
-      "rangeStepRight",
-      "reduce",
-      "reduceRight",
-      "replace",
-      "set",
-      "slice",
-      "sortedIndexBy",
-      "sortedLastIndexBy",
-      "transform",
-      "unionBy",
-      "unionWith",
-      "update",
-      "xorBy",
-      "xorWith",
-      "zipWith"
-    ],
-    "4": [
-      "fill",
-      "setWith",
-      "updateWith"
-    ]
-  };
-  exports.aryRearg = {
-    "2": [1, 0],
-    "3": [2, 0, 1],
-    "4": [3, 2, 0, 1]
-  };
-  exports.iterateeAry = {
-    "dropRightWhile": 1,
-    "dropWhile": 1,
-    "every": 1,
-    "filter": 1,
-    "find": 1,
-    "findFrom": 1,
-    "findIndex": 1,
-    "findIndexFrom": 1,
-    "findKey": 1,
-    "findLast": 1,
-    "findLastFrom": 1,
-    "findLastIndex": 1,
-    "findLastIndexFrom": 1,
-    "findLastKey": 1,
-    "flatMap": 1,
-    "flatMapDeep": 1,
-    "flatMapDepth": 1,
-    "forEach": 1,
-    "forEachRight": 1,
-    "forIn": 1,
-    "forInRight": 1,
-    "forOwn": 1,
-    "forOwnRight": 1,
-    "map": 1,
-    "mapKeys": 1,
-    "mapValues": 1,
-    "partition": 1,
-    "reduce": 2,
-    "reduceRight": 2,
-    "reject": 1,
-    "remove": 1,
-    "some": 1,
-    "takeRightWhile": 1,
-    "takeWhile": 1,
-    "times": 1,
-    "transform": 2
-  };
-  exports.iterateeRearg = {
-    "mapKeys": [1],
-    "reduceRight": [1, 0]
-  };
-  exports.methodRearg = {
-    "assignInAllWith": [1, 0],
-    "assignInWith": [1, 2, 0],
-    "assignAllWith": [1, 0],
-    "assignWith": [1, 2, 0],
-    "differenceBy": [1, 2, 0],
-    "differenceWith": [1, 2, 0],
-    "getOr": [2, 1, 0],
-    "intersectionBy": [1, 2, 0],
-    "intersectionWith": [1, 2, 0],
-    "isEqualWith": [1, 2, 0],
-    "isMatchWith": [2, 1, 0],
-    "mergeAllWith": [1, 0],
-    "mergeWith": [1, 2, 0],
-    "padChars": [2, 1, 0],
-    "padCharsEnd": [2, 1, 0],
-    "padCharsStart": [2, 1, 0],
-    "pullAllBy": [2, 1, 0],
-    "pullAllWith": [2, 1, 0],
-    "rangeStep": [1, 2, 0],
-    "rangeStepRight": [1, 2, 0],
-    "setWith": [3, 1, 2, 0],
-    "sortedIndexBy": [2, 1, 0],
-    "sortedLastIndexBy": [2, 1, 0],
-    "unionBy": [1, 2, 0],
-    "unionWith": [1, 2, 0],
-    "updateWith": [3, 1, 2, 0],
-    "xorBy": [1, 2, 0],
-    "xorWith": [1, 2, 0],
-    "zipWith": [1, 2, 0]
-  };
-  exports.methodSpread = {
-    "assignAll": { "start": 0 },
-    "assignAllWith": { "start": 0 },
-    "assignInAll": { "start": 0 },
-    "assignInAllWith": { "start": 0 },
-    "defaultsAll": { "start": 0 },
-    "defaultsDeepAll": { "start": 0 },
-    "invokeArgs": { "start": 2 },
-    "invokeArgsMap": { "start": 2 },
-    "mergeAll": { "start": 0 },
-    "mergeAllWith": { "start": 0 },
-    "partial": { "start": 1 },
-    "partialRight": { "start": 1 },
-    "without": { "start": 1 },
-    "zipAll": { "start": 0 }
-  };
-  exports.mutate = {
-    "array": {
-      "fill": true,
-      "pull": true,
-      "pullAll": true,
-      "pullAllBy": true,
-      "pullAllWith": true,
-      "pullAt": true,
-      "remove": true,
-      "reverse": true
-    },
-    "object": {
-      "assign": true,
-      "assignAll": true,
-      "assignAllWith": true,
-      "assignIn": true,
-      "assignInAll": true,
-      "assignInAllWith": true,
-      "assignInWith": true,
-      "assignWith": true,
-      "defaults": true,
-      "defaultsAll": true,
-      "defaultsDeep": true,
-      "defaultsDeepAll": true,
-      "merge": true,
-      "mergeAll": true,
-      "mergeAllWith": true,
-      "mergeWith": true
-    },
-    "set": {
-      "set": true,
-      "setWith": true,
-      "unset": true,
-      "update": true,
-      "updateWith": true
-    }
-  };
-  exports.realToAlias = function() {
-    var hasOwnProperty2 = Object.prototype.hasOwnProperty, object2 = exports.aliasToReal, result = {};
-    for (var key in object2) {
-      var value = object2[key];
-      if (hasOwnProperty2.call(result, value)) {
-        result[value].push(key);
-      } else {
-        result[value] = [key];
-      }
-    }
-    return result;
-  }();
-  exports.remap = {
-    "assignAll": "assign",
-    "assignAllWith": "assignWith",
-    "assignInAll": "assignIn",
-    "assignInAllWith": "assignInWith",
-    "curryN": "curry",
-    "curryRightN": "curryRight",
-    "defaultsAll": "defaults",
-    "defaultsDeepAll": "defaultsDeep",
-    "findFrom": "find",
-    "findIndexFrom": "findIndex",
-    "findLastFrom": "findLast",
-    "findLastIndexFrom": "findLastIndex",
-    "getOr": "get",
-    "includesFrom": "includes",
-    "indexOfFrom": "indexOf",
-    "invokeArgs": "invoke",
-    "invokeArgsMap": "invokeMap",
-    "lastIndexOfFrom": "lastIndexOf",
-    "mergeAll": "merge",
-    "mergeAllWith": "mergeWith",
-    "padChars": "pad",
-    "padCharsEnd": "padEnd",
-    "padCharsStart": "padStart",
-    "propertyOf": "get",
-    "rangeStep": "range",
-    "rangeStepRight": "rangeRight",
-    "restFrom": "rest",
-    "spreadFrom": "spread",
-    "trimChars": "trim",
-    "trimCharsEnd": "trimEnd",
-    "trimCharsStart": "trimStart",
-    "zipAll": "zip"
-  };
-  exports.skipFixed = {
-    "castArray": true,
-    "flow": true,
-    "flowRight": true,
-    "iteratee": true,
-    "mixin": true,
-    "rearg": true,
-    "runInContext": true
-  };
-  exports.skipRearg = {
-    "add": true,
-    "assign": true,
-    "assignIn": true,
-    "bind": true,
-    "bindKey": true,
-    "concat": true,
-    "difference": true,
-    "divide": true,
-    "eq": true,
-    "gt": true,
-    "gte": true,
-    "isEqual": true,
-    "lt": true,
-    "lte": true,
-    "matchesProperty": true,
-    "merge": true,
-    "multiply": true,
-    "overArgs": true,
-    "partial": true,
-    "partialRight": true,
-    "propertyOf": true,
-    "random": true,
-    "range": true,
-    "rangeRight": true,
-    "subtract": true,
-    "zip": true,
-    "zipObject": true,
-    "zipObjectDeep": true
-  };
-})(_mapping);
-var placeholder;
-var hasRequiredPlaceholder;
-function requirePlaceholder() {
-  if (hasRequiredPlaceholder) return placeholder;
-  hasRequiredPlaceholder = 1;
-  placeholder = {};
-  return placeholder;
-}
-var mapping = _mapping, fallbackHolder = requirePlaceholder();
-var push = Array.prototype.push;
-function baseArity(func2, n2) {
-  return n2 == 2 ? function(a2, b2) {
-    return func2.apply(void 0, arguments);
-  } : function(a2) {
-    return func2.apply(void 0, arguments);
-  };
-}
-function baseAry(func2, n2) {
-  return n2 == 2 ? function(a2, b2) {
-    return func2(a2, b2);
-  } : function(a2) {
-    return func2(a2);
-  };
-}
-function cloneArray(array2) {
-  var length = array2 ? array2.length : 0, result = Array(length);
-  while (length--) {
-    result[length] = array2[length];
-  }
-  return result;
-}
-function createCloner(func2) {
-  return function(object2) {
-    return func2({}, object2);
-  };
-}
-function flatSpread(func2, start) {
-  return function() {
-    var length = arguments.length, lastIndex = length - 1, args = Array(length);
-    while (length--) {
-      args[length] = arguments[length];
-    }
-    var array2 = args[start], otherArgs = args.slice(0, start);
-    if (array2) {
-      push.apply(otherArgs, array2);
-    }
-    if (start != lastIndex) {
-      push.apply(otherArgs, args.slice(start + 1));
-    }
-    return func2.apply(this, otherArgs);
-  };
-}
-function wrapImmutable(func2, cloner) {
-  return function() {
-    var length = arguments.length;
-    if (!length) {
-      return;
-    }
-    var args = Array(length);
-    while (length--) {
-      args[length] = arguments[length];
-    }
-    var result = args[0] = cloner.apply(void 0, args);
-    func2.apply(void 0, args);
-    return result;
-  };
-}
-function baseConvert$1(util2, name, func2, options) {
-  var isLib = typeof name == "function", isObj = name === Object(name);
-  if (isObj) {
-    options = func2;
-    func2 = name;
-    name = void 0;
-  }
-  if (func2 == null) {
-    throw new TypeError();
-  }
-  options || (options = {});
-  var config = {
-    "cap": "cap" in options ? options.cap : true,
-    "curry": "curry" in options ? options.curry : true,
-    "fixed": "fixed" in options ? options.fixed : true,
-    "immutable": "immutable" in options ? options.immutable : true,
-    "rearg": "rearg" in options ? options.rearg : true
-  };
-  var defaultHolder = isLib ? func2 : fallbackHolder, forceCurry = "curry" in options && options.curry, forceFixed = "fixed" in options && options.fixed, forceRearg = "rearg" in options && options.rearg, pristine = isLib ? func2.runInContext() : void 0;
-  var helpers = isLib ? func2 : {
-    "ary": util2.ary,
-    "assign": util2.assign,
-    "clone": util2.clone,
-    "curry": util2.curry,
-    "forEach": util2.forEach,
-    "isArray": util2.isArray,
-    "isError": util2.isError,
-    "isFunction": util2.isFunction,
-    "isWeakMap": util2.isWeakMap,
-    "iteratee": util2.iteratee,
-    "keys": util2.keys,
-    "rearg": util2.rearg,
-    "toInteger": util2.toInteger,
-    "toPath": util2.toPath
-  };
-  var ary2 = helpers.ary, assign2 = helpers.assign, clone2 = helpers.clone, curry2 = helpers.curry, each = helpers.forEach, isArray2 = helpers.isArray, isError2 = helpers.isError, isFunction2 = helpers.isFunction, isWeakMap2 = helpers.isWeakMap, keys2 = helpers.keys, rearg2 = helpers.rearg, toInteger2 = helpers.toInteger, toPath2 = helpers.toPath;
-  var aryMethodKeys = keys2(mapping.aryMethod);
-  var wrappers = {
-    "castArray": function(castArray) {
-      return function() {
-        var value = arguments[0];
-        return isArray2(value) ? castArray(cloneArray(value)) : castArray.apply(void 0, arguments);
-      };
-    },
-    "iteratee": function(iteratee2) {
-      return function() {
-        var func3 = arguments[0], arity = arguments[1], result = iteratee2(func3, arity), length = result.length;
-        if (config.cap && typeof arity == "number") {
-          arity = arity > 2 ? arity - 2 : 1;
-          return length && length <= arity ? result : baseAry(result, arity);
-        }
-        return result;
-      };
-    },
-    "mixin": function(mixin) {
-      return function(source) {
-        var func3 = this;
-        if (!isFunction2(func3)) {
-          return mixin(func3, Object(source));
-        }
-        var pairs2 = [];
-        each(keys2(source), function(key) {
-          if (isFunction2(source[key])) {
-            pairs2.push([key, func3.prototype[key]]);
-          }
-        });
-        mixin(func3, Object(source));
-        each(pairs2, function(pair) {
-          var value = pair[1];
-          if (isFunction2(value)) {
-            func3.prototype[pair[0]] = value;
-          } else {
-            delete func3.prototype[pair[0]];
-          }
-        });
-        return func3;
-      };
-    },
-    "nthArg": function(nthArg) {
-      return function(n2) {
-        var arity = n2 < 0 ? 1 : toInteger2(n2) + 1;
-        return curry2(nthArg(n2), arity);
-      };
-    },
-    "rearg": function(rearg3) {
-      return function(func3, indexes) {
-        var arity = indexes ? indexes.length : 0;
-        return curry2(rearg3(func3, indexes), arity);
-      };
-    },
-    "runInContext": function(runInContext) {
-      return function(context) {
-        return baseConvert$1(util2, runInContext(context), options);
-      };
-    }
-  };
-  function castCap(name2, func3) {
-    if (config.cap) {
-      var indexes = mapping.iterateeRearg[name2];
-      if (indexes) {
-        return iterateeRearg(func3, indexes);
-      }
-      var n2 = !isLib && mapping.iterateeAry[name2];
-      if (n2) {
-        return iterateeAry(func3, n2);
-      }
-    }
-    return func3;
-  }
-  function castCurry(name2, func3, n2) {
-    return forceCurry || config.curry && n2 > 1 ? curry2(func3, n2) : func3;
-  }
-  function castFixed(name2, func3, n2) {
-    if (config.fixed && (forceFixed || !mapping.skipFixed[name2])) {
-      var data = mapping.methodSpread[name2], start = data && data.start;
-      return start === void 0 ? ary2(func3, n2) : flatSpread(func3, start);
-    }
-    return func3;
-  }
-  function castRearg(name2, func3, n2) {
-    return config.rearg && n2 > 1 && (forceRearg || !mapping.skipRearg[name2]) ? rearg2(func3, mapping.methodRearg[name2] || mapping.aryRearg[n2]) : func3;
-  }
-  function cloneByPath(object2, path) {
-    path = toPath2(path);
-    var index = -1, length = path.length, lastIndex = length - 1, result = clone2(Object(object2)), nested = result;
-    while (nested != null && ++index < length) {
-      var key = path[index], value = nested[key];
-      if (value != null && !(isFunction2(value) || isError2(value) || isWeakMap2(value))) {
-        nested[key] = clone2(index == lastIndex ? value : Object(value));
-      }
-      nested = nested[key];
-    }
-    return result;
-  }
-  function convertLib(options2) {
-    return _2.runInContext.convert(options2)(void 0);
-  }
-  function createConverter(name2, func3) {
-    var realName = mapping.aliasToReal[name2] || name2, methodName = mapping.remap[realName] || realName, oldOptions = options;
-    return function(options2) {
-      var newUtil = isLib ? pristine : helpers, newFunc = isLib ? pristine[methodName] : func3, newOptions = assign2(assign2({}, oldOptions), options2);
-      return baseConvert$1(newUtil, realName, newFunc, newOptions);
-    };
-  }
-  function iterateeAry(func3, n2) {
-    return overArg2(func3, function(func4) {
-      return typeof func4 == "function" ? baseAry(func4, n2) : func4;
-    });
-  }
-  function iterateeRearg(func3, indexes) {
-    return overArg2(func3, function(func4) {
-      var n2 = indexes.length;
-      return baseArity(rearg2(baseAry(func4, n2), indexes), n2);
-    });
-  }
-  function overArg2(func3, transform) {
-    return function() {
-      var length = arguments.length;
-      if (!length) {
-        return func3();
-      }
-      var args = Array(length);
-      while (length--) {
-        args[length] = arguments[length];
-      }
-      var index = config.rearg ? 0 : length - 1;
-      args[index] = transform(args[index]);
-      return func3.apply(void 0, args);
-    };
-  }
-  function wrap(name2, func3, placeholder2) {
-    var result, realName = mapping.aliasToReal[name2] || name2, wrapped = func3, wrapper = wrappers[realName];
-    if (wrapper) {
-      wrapped = wrapper(func3);
-    } else if (config.immutable) {
-      if (mapping.mutate.array[realName]) {
-        wrapped = wrapImmutable(func3, cloneArray);
-      } else if (mapping.mutate.object[realName]) {
-        wrapped = wrapImmutable(func3, createCloner(func3));
-      } else if (mapping.mutate.set[realName]) {
-        wrapped = wrapImmutable(func3, cloneByPath);
-      }
-    }
-    each(aryMethodKeys, function(aryKey) {
-      each(mapping.aryMethod[aryKey], function(otherName) {
-        if (realName == otherName) {
-          var data = mapping.methodSpread[realName], afterRearg = data && data.afterRearg;
-          result = afterRearg ? castFixed(realName, castRearg(realName, wrapped, aryKey), aryKey) : castRearg(realName, castFixed(realName, wrapped, aryKey), aryKey);
-          result = castCap(realName, result);
-          result = castCurry(realName, result, aryKey);
-          return false;
-        }
-      });
-      return !result;
-    });
-    result || (result = wrapped);
-    if (result == func3) {
-      result = forceCurry ? curry2(result, 1) : function() {
-        return func3.apply(this, arguments);
-      };
-    }
-    result.convert = createConverter(realName, func3);
-    result.placeholder = func3.placeholder = placeholder2;
-    return result;
-  }
-  if (!isObj) {
-    return wrap(name, func2, defaultHolder);
-  }
-  var _2 = func2;
-  var pairs = [];
-  each(aryMethodKeys, function(aryKey) {
-    each(mapping.aryMethod[aryKey], function(key) {
-      var func3 = _2[mapping.remap[key] || key];
-      if (func3) {
-        pairs.push([key, wrap(key, func3, _2)]);
-      }
-    });
-  });
-  each(keys2(_2), function(key) {
-    var func3 = _2[key];
-    if (typeof func3 == "function") {
-      var length = pairs.length;
-      while (length--) {
-        if (pairs[length][0] == key) {
-          return;
-        }
-      }
-      func3.convert = createConverter(key, func3);
-      pairs.push([key, func3]);
-    }
-  });
-  each(pairs, function(pair) {
-    _2[pair[0]] = pair[1];
-  });
-  _2.convert = convertLib;
-  _2.placeholder = _2;
-  each(keys2(_2), function(key) {
-    each(mapping.realToAlias[key] || [], function(alias) {
-      _2[alias] = _2[key];
-    });
-  });
-  return _2;
-}
-var _baseConvert = baseConvert$1;
 var getNative$3 = _getNative, root$7 = _root;
 var WeakMap$2 = getNative$3(root$7, "WeakMap");
 var _WeakMap = WeakMap$2;
@@ -9440,10 +8610,10 @@ function composeArgsRight$2(args, partials, holders, isCurried) {
   return result;
 }
 var _composeArgsRight = composeArgsRight$2;
-function countHolders$1(array2, placeholder2) {
+function countHolders$1(array2, placeholder) {
   var length = array2.length, result = 0;
   while (length--) {
-    if (array2[length] === placeholder2) {
+    if (array2[length] === placeholder) {
       ++result;
     }
   }
@@ -9682,7 +8852,7 @@ function setWrapToString$2(wrapper, reference, bitmask) {
 var _setWrapToString = setWrapToString$2;
 var isLaziable = require_isLaziable(), setData$1 = _setData, setWrapToString$1 = _setWrapToString;
 var WRAP_BIND_FLAG$4 = 1, WRAP_BIND_KEY_FLAG$3 = 2, WRAP_CURRY_BOUND_FLAG$1 = 4, WRAP_CURRY_FLAG$4 = 8, WRAP_PARTIAL_FLAG$1 = 32, WRAP_PARTIAL_RIGHT_FLAG$1 = 64;
-function createRecurry$2(func2, bitmask, wrapFunc, placeholder2, thisArg, partials, holders, argPos, ary2, arity) {
+function createRecurry$2(func2, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary2, arity) {
   var isCurry = bitmask & WRAP_CURRY_FLAG$4, newHolders = isCurry ? holders : void 0, newHoldersRight = isCurry ? void 0 : holders, newPartials = isCurry ? partials : void 0, newPartialsRight = isCurry ? void 0 : partials;
   bitmask |= isCurry ? WRAP_PARTIAL_FLAG$1 : WRAP_PARTIAL_RIGHT_FLAG$1;
   bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG$1 : WRAP_PARTIAL_FLAG$1);
@@ -9705,7 +8875,7 @@ function createRecurry$2(func2, bitmask, wrapFunc, placeholder2, thisArg, partia
   if (isLaziable(func2)) {
     setData$1(result, newData);
   }
-  result.placeholder = placeholder2;
+  result.placeholder = placeholder;
   return setWrapToString$1(result, func2, bitmask);
 }
 var _createRecurry = createRecurry$2;
@@ -9726,11 +8896,11 @@ function reorder$1(array2, indexes) {
 }
 var _reorder = reorder$1;
 var PLACEHOLDER$1 = "__lodash_placeholder__";
-function replaceHolders$3(array2, placeholder2) {
+function replaceHolders$3(array2, placeholder) {
   var index = -1, length = array2.length, resIndex = 0, result = [];
   while (++index < length) {
     var value = array2[index];
-    if (value === placeholder2 || value === PLACEHOLDER$1) {
+    if (value === placeholder || value === PLACEHOLDER$1) {
       array2[index] = PLACEHOLDER$1;
       result[resIndex++] = index;
     }
@@ -9748,7 +8918,7 @@ function createHybrid$2(func2, bitmask, thisArg, partials, holders, partialsRigh
       args[index] = arguments[index];
     }
     if (isCurried) {
-      var placeholder2 = getHolder$1(wrapper), holdersCount = countHolders(args, placeholder2);
+      var placeholder = getHolder$1(wrapper), holdersCount = countHolders(args, placeholder);
     }
     if (partials) {
       args = composeArgs$1(args, partials, holders, isCurried);
@@ -9758,7 +8928,7 @@ function createHybrid$2(func2, bitmask, thisArg, partials, holders, partialsRigh
     }
     length -= holdersCount;
     if (isCurried && length < arity) {
-      var newHolders = replaceHolders$2(args, placeholder2);
+      var newHolders = replaceHolders$2(args, placeholder);
       return createRecurry$1(
         func2,
         bitmask,
@@ -9794,11 +8964,11 @@ var apply$2 = _apply, createCtor$1 = _createCtor, createHybrid$1 = _createHybrid
 function createCurry$1(func2, bitmask, arity) {
   var Ctor = createCtor$1(func2);
   function wrapper() {
-    var length = arguments.length, args = Array(length), index = length, placeholder2 = getHolder(wrapper);
+    var length = arguments.length, args = Array(length), index = length, placeholder = getHolder(wrapper);
     while (index--) {
       args[index] = arguments[index];
     }
-    var holders = length < 3 && args[0] !== placeholder2 && args[length - 1] !== placeholder2 ? [] : replaceHolders$1(args, placeholder2);
+    var holders = length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder ? [] : replaceHolders$1(args, placeholder);
     length -= holders.length;
     if (length < arity) {
       return createRecurry(