@mattisvensson/strapi-plugin-webatlas 0.3.1 → 0.4.2

package/dist/_chunks/_baseConvert-C2SW1VHq.mjs

@@ -1,865 +0,0 @@
-var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-function getAugmentedNamespace(n) {
-  if (n.__esModule) return n;
-  var f = n.default;
-  if (typeof f == "function") {
-    var a = function a2() {
-      if (this instanceof a2) {
-        return Reflect.construct(f, arguments, this.constructor);
-      }
-      return f.apply(this, arguments);
-    };
-    a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, "__esModule", { value: true });
-  Object.keys(n).forEach(function(k) {
-    var d = Object.getOwnPropertyDescriptor(n, k);
-    Object.defineProperty(a, k, d.get ? d : {
-      enumerable: true,
-      get: function() {
-        return n[k];
-      }
-    });
-  });
-  return a;
-}
-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 hasOwnProperty = Object.prototype.hasOwnProperty, object = exports.aliasToReal, result = {};
-    for (var key in object) {
-      var value = object[key];
-      if (hasOwnProperty.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(func, n) {
-  return n == 2 ? function(a, b) {
-    return func.apply(void 0, arguments);
-  } : function(a) {
-    return func.apply(void 0, arguments);
-  };
-}
-function baseAry(func, n) {
-  return n == 2 ? function(a, b) {
-    return func(a, b);
-  } : function(a) {
-    return func(a);
-  };
-}
-function cloneArray(array) {
-  var length = array ? array.length : 0, result = Array(length);
-  while (length--) {
-    result[length] = array[length];
-  }
-  return result;
-}
-function createCloner(func) {
-  return function(object) {
-    return func({}, object);
-  };
-}
-function flatSpread(func, start) {
-  return function() {
-    var length = arguments.length, lastIndex = length - 1, args = Array(length);
-    while (length--) {
-      args[length] = arguments[length];
-    }
-    var array = args[start], otherArgs = args.slice(0, start);
-    if (array) {
-      push.apply(otherArgs, array);
-    }
-    if (start != lastIndex) {
-      push.apply(otherArgs, args.slice(start + 1));
-    }
-    return func.apply(this, otherArgs);
-  };
-}
-function wrapImmutable(func, 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);
-    func.apply(void 0, args);
-    return result;
-  };
-}
-function baseConvert(util, name, func, options) {
-  var isLib = typeof name == "function", isObj = name === Object(name);
-  if (isObj) {
-    options = func;
-    func = name;
-    name = void 0;
-  }
-  if (func == 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 ? func : fallbackHolder, forceCurry = "curry" in options && options.curry, forceFixed = "fixed" in options && options.fixed, forceRearg = "rearg" in options && options.rearg, pristine = isLib ? func.runInContext() : void 0;
-  var helpers = isLib ? func : {
-    "ary": util.ary,
-    "assign": util.assign,
-    "clone": util.clone,
-    "curry": util.curry,
-    "forEach": util.forEach,
-    "isArray": util.isArray,
-    "isError": util.isError,
-    "isFunction": util.isFunction,
-    "isWeakMap": util.isWeakMap,
-    "iteratee": util.iteratee,
-    "keys": util.keys,
-    "rearg": util.rearg,
-    "toInteger": util.toInteger,
-    "toPath": util.toPath
-  };
-  var ary = helpers.ary, assign = helpers.assign, clone = helpers.clone, curry = helpers.curry, each = helpers.forEach, isArray = helpers.isArray, isError = helpers.isError, isFunction = helpers.isFunction, isWeakMap = helpers.isWeakMap, keys = helpers.keys, rearg = helpers.rearg, toInteger = helpers.toInteger, toPath = helpers.toPath;
-  var aryMethodKeys = keys(mapping.aryMethod);
-  var wrappers = {
-    "castArray": function(castArray) {
-      return function() {
-        var value = arguments[0];
-        return isArray(value) ? castArray(cloneArray(value)) : castArray.apply(void 0, arguments);
-      };
-    },
-    "iteratee": function(iteratee) {
-      return function() {
-        var func2 = arguments[0], arity = arguments[1], result = iteratee(func2, 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 func2 = this;
-        if (!isFunction(func2)) {
-          return mixin(func2, Object(source));
-        }
-        var pairs2 = [];
-        each(keys(source), function(key) {
-          if (isFunction(source[key])) {
-            pairs2.push([key, func2.prototype[key]]);
-          }
-        });
-        mixin(func2, Object(source));
-        each(pairs2, function(pair) {
-          var value = pair[1];
-          if (isFunction(value)) {
-            func2.prototype[pair[0]] = value;
-          } else {
-            delete func2.prototype[pair[0]];
-          }
-        });
-        return func2;
-      };
-    },
-    "nthArg": function(nthArg) {
-      return function(n) {
-        var arity = n < 0 ? 1 : toInteger(n) + 1;
-        return curry(nthArg(n), arity);
-      };
-    },
-    "rearg": function(rearg2) {
-      return function(func2, indexes) {
-        var arity = indexes ? indexes.length : 0;
-        return curry(rearg2(func2, indexes), arity);
-      };
-    },
-    "runInContext": function(runInContext) {
-      return function(context) {
-        return baseConvert(util, runInContext(context), options);
-      };
-    }
-  };
-  function castCap(name2, func2) {
-    if (config.cap) {
-      var indexes = mapping.iterateeRearg[name2];
-      if (indexes) {
-        return iterateeRearg(func2, indexes);
-      }
-      var n = !isLib && mapping.iterateeAry[name2];
-      if (n) {
-        return iterateeAry(func2, n);
-      }
-    }
-    return func2;
-  }
-  function castCurry(name2, func2, n) {
-    return forceCurry || config.curry && n > 1 ? curry(func2, n) : func2;
-  }
-  function castFixed(name2, func2, n) {
-    if (config.fixed && (forceFixed || !mapping.skipFixed[name2])) {
-      var data = mapping.methodSpread[name2], start = data && data.start;
-      return start === void 0 ? ary(func2, n) : flatSpread(func2, start);
-    }
-    return func2;
-  }
-  function castRearg(name2, func2, n) {
-    return config.rearg && n > 1 && (forceRearg || !mapping.skipRearg[name2]) ? rearg(func2, mapping.methodRearg[name2] || mapping.aryRearg[n]) : func2;
-  }
-  function cloneByPath(object, path) {
-    path = toPath(path);
-    var index = -1, length = path.length, lastIndex = length - 1, result = clone(Object(object)), nested = result;
-    while (nested != null && ++index < length) {
-      var key = path[index], value = nested[key];
-      if (value != null && !(isFunction(value) || isError(value) || isWeakMap(value))) {
-        nested[key] = clone(index == lastIndex ? value : Object(value));
-      }
-      nested = nested[key];
-    }
-    return result;
-  }
-  function convertLib(options2) {
-    return _.runInContext.convert(options2)(void 0);
-  }
-  function createConverter(name2, func2) {
-    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] : func2, newOptions = assign(assign({}, oldOptions), options2);
-      return baseConvert(newUtil, realName, newFunc, newOptions);
-    };
-  }
-  function iterateeAry(func2, n) {
-    return overArg(func2, function(func3) {
-      return typeof func3 == "function" ? baseAry(func3, n) : func3;
-    });
-  }
-  function iterateeRearg(func2, indexes) {
-    return overArg(func2, function(func3) {
-      var n = indexes.length;
-      return baseArity(rearg(baseAry(func3, n), indexes), n);
-    });
-  }
-  function overArg(func2, transform) {
-    return function() {
-      var length = arguments.length;
-      if (!length) {
-        return func2();
-      }
-      var args = Array(length);
-      while (length--) {
-        args[length] = arguments[length];
-      }
-      var index = config.rearg ? 0 : length - 1;
-      args[index] = transform(args[index]);
-      return func2.apply(void 0, args);
-    };
-  }
-  function wrap(name2, func2, placeholder2) {
-    var result, realName = mapping.aliasToReal[name2] || name2, wrapped = func2, wrapper = wrappers[realName];
-    if (wrapper) {
-      wrapped = wrapper(func2);
-    } else if (config.immutable) {
-      if (mapping.mutate.array[realName]) {
-        wrapped = wrapImmutable(func2, cloneArray);
-      } else if (mapping.mutate.object[realName]) {
-        wrapped = wrapImmutable(func2, createCloner(func2));
-      } else if (mapping.mutate.set[realName]) {
-        wrapped = wrapImmutable(func2, 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 == func2) {
-      result = forceCurry ? curry(result, 1) : function() {
-        return func2.apply(this, arguments);
-      };
-    }
-    result.convert = createConverter(realName, func2);
-    result.placeholder = func2.placeholder = placeholder2;
-    return result;
-  }
-  if (!isObj) {
-    return wrap(name, func, defaultHolder);
-  }
-  var _ = func;
-  var pairs = [];
-  each(aryMethodKeys, function(aryKey) {
-    each(mapping.aryMethod[aryKey], function(key) {
-      var func2 = _[mapping.remap[key] || key];
-      if (func2) {
-        pairs.push([key, wrap(key, func2, _)]);
-      }
-    });
-  });
-  each(keys(_), function(key) {
-    var func2 = _[key];
-    if (typeof func2 == "function") {
-      var length = pairs.length;
-      while (length--) {
-        if (pairs[length][0] == key) {
-          return;
-        }
-      }
-      func2.convert = createConverter(key, func2);
-      pairs.push([key, func2]);
-    }
-  });
-  each(pairs, function(pair) {
-    _[pair[0]] = pair[1];
-  });
-  _.convert = convertLib;
-  _.placeholder = _;
-  each(keys(_), function(key) {
-    each(mapping.realToAlias[key] || [], function(alias) {
-      _[alias] = _[key];
-    });
-  });
-  return _;
-}
-var _baseConvert = baseConvert;
-export {
-  _baseConvert as _,
-  getDefaultExportFromCjs as a,
-  commonjsGlobal as c,
-  getAugmentedNamespace as g,
-  requirePlaceholder as r
-};