@mattisvensson/strapi-plugin-webatlas 0.2.0 → 0.2.1

package/dist/_chunks/_baseConvert-C2SW1VHq.mjs

@@ -0,0 +1,865 @@
+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
+};