@fecp/mobile 1.1.52 → 1.1.54

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/arrayLastIndexOf.mjs

@@ -0,0 +1,22 @@
+var arrayLastIndexOf_1;
+var hasRequiredArrayLastIndexOf;
+function requireArrayLastIndexOf() {
+  if (hasRequiredArrayLastIndexOf) return arrayLastIndexOf_1;
+  hasRequiredArrayLastIndexOf = 1;
+  function arrayLastIndexOf(list, val) {
+    if (list.lastIndexOf) {
+      return list.lastIndexOf(val);
+    }
+    for (var len = list.length - 1; len >= 0; len--) {
+      if (val === list[len]) {
+        return len;
+      }
+    }
+    return -1;
+  }
+  arrayLastIndexOf_1 = arrayLastIndexOf;
+  return arrayLastIndexOf_1;
+}
+export {
+  requireArrayLastIndexOf as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/assign.mjs

@@ -0,0 +1,46 @@
+import { __require as requireArrayEach } from "./arrayEach.mjs";
+import { __require as requireKeys } from "./keys.mjs";
+import { __require as requireIsArray } from "./isArray.mjs";
+import { __require as requireClone } from "./clone.mjs";
+var assign_1;
+var hasRequiredAssign;
+function requireAssign() {
+  if (hasRequiredAssign) return assign_1;
+  hasRequiredAssign = 1;
+  var arrayEach = requireArrayEach();
+  var keys = requireKeys();
+  var isArray = requireIsArray();
+  var clone = requireClone();
+  var objectAssignFns = Object.assign;
+  function handleAssign(destination, args, isClone) {
+    var len = args.length;
+    for (var source, index = 1; index < len; index++) {
+      source = args[index];
+      arrayEach(keys(args[index]), isClone ? function(key) {
+        destination[key] = clone(source[key], isClone);
+      } : function(key) {
+        destination[key] = source[key];
+      });
+    }
+    return destination;
+  }
+  var assign = function(target) {
+    if (target) {
+      var args = arguments;
+      if (target === true) {
+        if (args.length > 1) {
+          target = isArray(target[1]) ? [] : {};
+          return handleAssign(target, args, true);
+        }
+      } else {
+        return objectAssignFns ? objectAssignFns.apply(Object, args) : handleAssign(target, args);
+      }
+    }
+    return target;
+  };
+  assign_1 = assign;
+  return assign_1;
+}
+export {
+  requireAssign as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/before.mjs

@@ -0,0 +1,26 @@
+import { __require as requireSlice } from "./slice.mjs";
+var before_1;
+var hasRequiredBefore;
+function requireBefore() {
+  if (hasRequiredBefore) return before_1;
+  hasRequiredBefore = 1;
+  var slice = requireSlice();
+  function before(count, callback, context) {
+    var runCount = 0;
+    var rests = [];
+    context = context || this;
+    return function() {
+      var args = arguments;
+      runCount++;
+      if (runCount < count) {
+        rests.push(args[0]);
+        callback.apply(context, [rests].concat(slice(args)));
+      }
+    };
+  }
+  before_1 = before;
+  return before_1;
+}
+export {
+  requireBefore as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/bind.mjs

@@ -0,0 +1,19 @@
+import { __require as requireSlice } from "./slice.mjs";
+var bind_1;
+var hasRequiredBind;
+function requireBind() {
+  if (hasRequiredBind) return bind_1;
+  hasRequiredBind = 1;
+  var slice = requireSlice();
+  function bind(callback, context) {
+    var args = slice(arguments, 2);
+    return function() {
+      return callback.apply(context, slice(arguments).concat(args));
+    };
+  }
+  bind_1 = bind;
+  return bind_1;
+}
+export {
+  requireBind as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/browse.mjs

@@ -0,0 +1,78 @@
+import { __require as requireStaticStrUndefined } from "./staticStrUndefined.mjs";
+import { __require as requireStaticDocument } from "./staticDocument.mjs";
+import { __require as requireStaticWindow } from "./staticWindow.mjs";
+import { __require as requireAssign } from "./assign.mjs";
+import { __require as requireArrayEach } from "./arrayEach.mjs";
+var browse_1;
+var hasRequiredBrowse;
+function requireBrowse() {
+  if (hasRequiredBrowse) return browse_1;
+  hasRequiredBrowse = 1;
+  var staticStrUndefined = requireStaticStrUndefined();
+  var staticDocument = requireStaticDocument();
+  var staticWindow = requireStaticWindow();
+  var assign = requireAssign();
+  var arrayEach = requireArrayEach();
+  function isBrowseStorage(storage) {
+    try {
+      var testKey = "__xe_t";
+      storage.setItem(testKey, 1);
+      storage.removeItem(testKey);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  function isBrowseType(type) {
+    return navigator.userAgent.indexOf(type) > -1;
+  }
+  function browse() {
+    var $body, isChrome, isEdge;
+    var isMobile = false;
+    var isLocalStorage = false;
+    var isSessionStorage = false;
+    var result = {
+      isNode: false,
+      isMobile,
+      isPC: false,
+      isDoc: !!staticDocument
+    };
+    if (!staticWindow && typeof process !== staticStrUndefined) {
+      result.isNode = true;
+    } else {
+      isEdge = isBrowseType("Edge");
+      isChrome = isBrowseType("Chrome");
+      isMobile = /(Android|webOS|iPhone|iPad|iPod|SymbianOS|BlackBerry|Windows Phone)/.test(navigator.userAgent);
+      if (result.isDoc) {
+        $body = staticDocument.body || staticDocument.documentElement;
+        arrayEach(["webkit", "khtml", "moz", "ms", "o"], function(core) {
+          result["-" + core] = !!$body[core + "MatchesSelector"];
+        });
+      }
+      try {
+        isLocalStorage = isBrowseStorage(staticWindow.localStorage);
+      } catch (e) {
+      }
+      try {
+        isSessionStorage = isBrowseStorage(staticWindow.sessionStorage);
+      } catch (e) {
+      }
+      assign(result, {
+        edge: isEdge,
+        firefox: isBrowseType("Firefox"),
+        msie: !isEdge && result["-ms"],
+        safari: !isChrome && !isEdge && isBrowseType("Safari"),
+        isMobile,
+        isPC: !isMobile,
+        isLocalStorage,
+        isSessionStorage
+      });
+    }
+    return result;
+  }
+  browse_1 = browse;
+  return browse_1;
+}
+export {
+  requireBrowse as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/camelCase.mjs

@@ -0,0 +1,50 @@
+import { __require as requireToValueString } from "./toValueString.mjs";
+import { __require as requireHelperStringSubstring } from "./helperStringSubstring.mjs";
+import { __require as requireHelperStringUpperCase } from "./helperStringUpperCase.mjs";
+import { __require as requireHelperStringLowerCase } from "./helperStringLowerCase.mjs";
+var camelCase_1;
+var hasRequiredCamelCase;
+function requireCamelCase() {
+  if (hasRequiredCamelCase) return camelCase_1;
+  hasRequiredCamelCase = 1;
+  var toValueString = requireToValueString();
+  var helperStringSubstring = requireHelperStringSubstring();
+  var helperStringUpperCase = requireHelperStringUpperCase();
+  var helperStringLowerCase = requireHelperStringLowerCase();
+  var camelCacheMaps = {};
+  function camelCase(str) {
+    str = toValueString(str);
+    if (camelCacheMaps[str]) {
+      return camelCacheMaps[str];
+    }
+    var strLen = str.length;
+    var rest = str.replace(/([-]+)/g, function(text, flag, index) {
+      return index && index + flag.length < strLen ? "-" : "";
+    });
+    strLen = rest.length;
+    rest = rest.replace(/([A-Z]+)/g, function(text, upper, index) {
+      var upperLen = upper.length;
+      upper = helperStringLowerCase(upper);
+      if (index) {
+        if (upperLen > 2 && index + upperLen < strLen) {
+          return helperStringUpperCase(helperStringSubstring(upper, 0, 1)) + helperStringSubstring(upper, 1, upperLen - 1) + helperStringUpperCase(helperStringSubstring(upper, upperLen - 1, upperLen));
+        }
+        return helperStringUpperCase(helperStringSubstring(upper, 0, 1)) + helperStringSubstring(upper, 1, upperLen);
+      } else {
+        if (upperLen > 1 && index + upperLen < strLen) {
+          return helperStringSubstring(upper, 0, upperLen - 1) + helperStringUpperCase(helperStringSubstring(upper, upperLen - 1, upperLen));
+        }
+      }
+      return upper;
+    }).replace(/(-[a-zA-Z])/g, function(text, upper) {
+      return helperStringUpperCase(helperStringSubstring(upper, 1, upper.length));
+    });
+    camelCacheMaps[str] = rest;
+    return rest;
+  }
+  camelCase_1 = camelCase;
+  return camelCase_1;
+}
+export {
+  requireCamelCase as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/ceil.mjs

@@ -0,0 +1,14 @@
+import { __require as requireHelperCreateMathNumber } from "./helperCreateMathNumber.mjs";
+var ceil_1;
+var hasRequiredCeil;
+function requireCeil() {
+  if (hasRequiredCeil) return ceil_1;
+  hasRequiredCeil = 1;
+  var helperCreateMathNumber = requireHelperCreateMathNumber();
+  var ceil = helperCreateMathNumber("ceil");
+  ceil_1 = ceil;
+  return ceil_1;
+}
+export {
+  requireCeil as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/chunk.mjs

@@ -0,0 +1,30 @@
+import { __require as requireIsArray } from "./isArray.mjs";
+var chunk_1;
+var hasRequiredChunk;
+function requireChunk() {
+  if (hasRequiredChunk) return chunk_1;
+  hasRequiredChunk = 1;
+  var isArray = requireIsArray();
+  function chunk(array, size) {
+    var index;
+    var result = [];
+    var arrLen = size >> 0 || 1;
+    if (isArray(array)) {
+      if (arrLen >= 0 && array.length > arrLen) {
+        index = 0;
+        while (index < array.length) {
+          result.push(array.slice(index, index + arrLen));
+          index += arrLen;
+        }
+      } else {
+        result = array.length ? [array] : array;
+      }
+    }
+    return result;
+  }
+  chunk_1 = chunk;
+  return chunk_1;
+}
+export {
+  requireChunk as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/clear.mjs

@@ -0,0 +1,56 @@
+import { __require as requireHelperDeleteProperty } from "./helperDeleteProperty.mjs";
+import { __require as requireIsPlainObject } from "./isPlainObject.mjs";
+import { __require as requireIsObject } from "./isObject.mjs";
+import { __require as requireIsArray } from "./isArray.mjs";
+import { __require as requireIsNull } from "./isNull.mjs";
+import { __require as requireAssign } from "./assign.mjs";
+import { __require as requireObjectEach } from "./objectEach.mjs";
+var clear_1;
+var hasRequiredClear;
+function requireClear() {
+  if (hasRequiredClear) return clear_1;
+  hasRequiredClear = 1;
+  var helperDeleteProperty = requireHelperDeleteProperty();
+  var isPlainObject = requireIsPlainObject();
+  var isObject = requireIsObject();
+  var isArray = requireIsArray();
+  var isNull = requireIsNull();
+  var assign = requireAssign();
+  var objectEach = requireObjectEach();
+  function clear(obj, defs, assigns) {
+    if (obj) {
+      var len;
+      var isDefs = arguments.length > 1 && (isNull(defs) || !isObject(defs));
+      var extds = isDefs ? assigns : defs;
+      if (isPlainObject(obj)) {
+        objectEach(obj, isDefs ? function(val, key) {
+          obj[key] = defs;
+        } : function(val, key) {
+          helperDeleteProperty(obj, key);
+        });
+        if (extds) {
+          assign(obj, extds);
+        }
+      } else if (isArray(obj)) {
+        if (isDefs) {
+          len = obj.length;
+          while (len > 0) {
+            len--;
+            obj[len] = defs;
+          }
+        } else {
+          obj.length = 0;
+        }
+        if (extds) {
+          obj.push.apply(obj, extds);
+        }
+      }
+    }
+    return obj;
+  }
+  clear_1 = clear;
+  return clear_1;
+}
+export {
+  requireClear as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/clone.mjs

@@ -0,0 +1,70 @@
+import { __require as requireStaticObjectToString } from "./staticObjectToString.mjs";
+import { __require as requireObjectEach } from "./objectEach.mjs";
+import { __require as requireArrayEach } from "./arrayEach.mjs";
+var clone_1;
+var hasRequiredClone;
+function requireClone() {
+  if (hasRequiredClone) return clone_1;
+  hasRequiredClone = 1;
+  var objectToString = requireStaticObjectToString();
+  var objectEach = requireObjectEach();
+  var arrayEach = requireArrayEach();
+  function getCativeCtor(val, args) {
+    var Ctor = val.__proto__.constructor;
+    return args ? new Ctor(args) : new Ctor();
+  }
+  function handleValueClone(item, isDeep) {
+    return isDeep ? copyValue(item, isDeep) : item;
+  }
+  function copyValue(val, isDeep) {
+    if (val) {
+      switch (objectToString.call(val)) {
+        case "[object Object]": {
+          var restObj = Object.create(Object.getPrototypeOf(val));
+          objectEach(val, function(item, key) {
+            restObj[key] = handleValueClone(item, isDeep);
+          });
+          return restObj;
+        }
+        case "[object Date]":
+        case "[object RegExp]": {
+          return getCativeCtor(val, val.valueOf());
+        }
+        case "[object Array]":
+        case "[object Arguments]": {
+          var restArr = [];
+          arrayEach(val, function(item) {
+            restArr.push(handleValueClone(item, isDeep));
+          });
+          return restArr;
+        }
+        case "[object Set]": {
+          var restSet = getCativeCtor(val);
+          restSet.forEach(function(item) {
+            restSet.add(handleValueClone(item, isDeep));
+          });
+          return restSet;
+        }
+        case "[object Map]": {
+          var restMap = getCativeCtor(val);
+          restMap.forEach(function(item, key) {
+            restMap.set(key, handleValueClone(item, isDeep));
+          });
+          return restMap;
+        }
+      }
+    }
+    return val;
+  }
+  function clone(obj, deep) {
+    if (obj) {
+      return copyValue(obj, deep);
+    }
+    return obj;
+  }
+  clone_1 = clone;
+  return clone_1;
+}
+export {
+  requireClone as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/commafy.mjs

@@ -0,0 +1,53 @@
+import { __require as requireSetupDefaults } from "./setupDefaults.mjs";
+import { __require as requireRound } from "./round.mjs";
+import { __require as requireCeil } from "./ceil.mjs";
+import { __require as requireFloor } from "./floor.mjs";
+import { __require as requireIsNumber } from "./isNumber.mjs";
+import { __require as requireToValueString } from "./toValueString.mjs";
+import { __require as requireToFixed } from "./toFixed.mjs";
+import { __require as requireToNumberString } from "./toNumberString.mjs";
+import { __require as requireAssign } from "./assign.mjs";
+var commafy_1;
+var hasRequiredCommafy;
+function requireCommafy() {
+  if (hasRequiredCommafy) return commafy_1;
+  hasRequiredCommafy = 1;
+  var setupDefaults = requireSetupDefaults();
+  var round = requireRound();
+  var ceil = requireCeil();
+  var floor = requireFloor();
+  var isNumber = requireIsNumber();
+  var toValueString = requireToValueString();
+  var toFixed = requireToFixed();
+  var toNumberString = requireToNumberString();
+  var assign = requireAssign();
+  function commafy(num, options) {
+    var opts = assign({}, setupDefaults.commafyOptions, options);
+    var optDigits = opts.digits;
+    var isNum = isNumber(num);
+    var rest, result, isNegative, intStr, floatStr;
+    if (isNum) {
+      rest = (opts.ceil ? ceil : opts.floor ? floor : round)(num, optDigits);
+      result = toNumberString(optDigits ? toFixed(rest, optDigits) : rest).split(".");
+      intStr = result[0];
+      floatStr = result[1];
+      isNegative = intStr && rest < 0;
+      if (isNegative) {
+        intStr = intStr.substring(1, intStr.length);
+      }
+    } else {
+      rest = toValueString(num).replace(/,/g, "");
+      result = rest ? [rest] : [];
+      intStr = result[0];
+    }
+    if (result.length) {
+      return (isNegative ? "-" : "") + intStr.replace(new RegExp("(?=(?!(\\b))(.{" + (opts.spaceNumber || 3) + "})+$)", "g"), opts.separator || ",") + (floatStr ? "." + floatStr : "");
+    }
+    return rest;
+  }
+  commafy_1 = commafy;
+  return commafy_1;
+}
+export {
+  requireCommafy as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/cookie.mjs

@@ -0,0 +1,153 @@
+import { __require as requireSetupDefaults } from "./setupDefaults.mjs";
+import { __require as requireStaticDocument } from "./staticDocument.mjs";
+import { __require as requireStaticDecodeURIComponent } from "./staticDecodeURIComponent.mjs";
+import { __require as requireStaticEncodeURIComponent } from "./staticEncodeURIComponent.mjs";
+import { __require as requireIsArray } from "./isArray.mjs";
+import { __require as requireIsObject } from "./isObject.mjs";
+import { __require as requireIsDate } from "./isDate.mjs";
+import { __require as requireIsUndefined } from "./isUndefined.mjs";
+import { __require as requireIncludes } from "./includes.mjs";
+import { __require as requireKeys } from "./keys.mjs";
+import { __require as requireAssign } from "./assign.mjs";
+import { __require as requireArrayEach } from "./arrayEach.mjs";
+import { __require as requireHelperNewDate } from "./helperNewDate.mjs";
+import { __require as requireHelperGetDateTime } from "./helperGetDateTime.mjs";
+import { __require as requireGetWhatYear } from "./getWhatYear.mjs";
+import { __require as requireGetWhatMonth } from "./getWhatMonth.mjs";
+import { __require as requireGetWhatDay } from "./getWhatDay.mjs";
+var cookie_1;
+var hasRequiredCookie;
+function requireCookie() {
+  if (hasRequiredCookie) return cookie_1;
+  hasRequiredCookie = 1;
+  var setupDefaults = requireSetupDefaults();
+  var staticDocument = requireStaticDocument();
+  var staticDecodeURIComponent = requireStaticDecodeURIComponent();
+  var staticEncodeURIComponent = requireStaticEncodeURIComponent();
+  var isArray = requireIsArray();
+  var isObject = requireIsObject();
+  var isDate = requireIsDate();
+  var isUndefined = requireIsUndefined();
+  var includes = requireIncludes();
+  var keys = requireKeys();
+  var assign = requireAssign();
+  var arrayEach = requireArrayEach();
+  var helperNewDate = requireHelperNewDate();
+  var helperGetDateTime = requireHelperGetDateTime();
+  var getWhatYear = requireGetWhatYear();
+  var getWhatMonth = requireGetWhatMonth();
+  var getWhatDay = requireGetWhatDay();
+  function toCookieUnitTime(unit, expires) {
+    var num = parseFloat(expires);
+    var nowdate = helperNewDate();
+    var time = helperGetDateTime(nowdate);
+    switch (unit) {
+      case "y":
+        return helperGetDateTime(getWhatYear(nowdate, num));
+      case "M":
+        return helperGetDateTime(getWhatMonth(nowdate, num));
+      case "d":
+        return helperGetDateTime(getWhatDay(nowdate, num));
+      case "h":
+      case "H":
+        return time + num * 60 * 60 * 1e3;
+      case "m":
+        return time + num * 60 * 1e3;
+      case "s":
+        return time + num * 1e3;
+    }
+    return time;
+  }
+  function toCookieUTCString(date) {
+    return (isDate(date) ? date : new Date(date)).toUTCString();
+  }
+  function cookie(name, value, options) {
+    if (staticDocument) {
+      var opts, expires, values, result, cookies, keyIndex;
+      var inserts = [];
+      var args = arguments;
+      if (isArray(name)) {
+        inserts = name;
+      } else if (args.length > 1) {
+        inserts = [assign({ name, value }, options)];
+      } else if (isObject(name)) {
+        inserts = [name];
+      }
+      if (inserts.length > 0) {
+        arrayEach(inserts, function(obj) {
+          opts = assign({}, setupDefaults.cookies, obj);
+          values = [];
+          if (opts.name) {
+            expires = opts.expires;
+            values.push(staticEncodeURIComponent(opts.name) + "=" + staticEncodeURIComponent(isObject(opts.value) ? JSON.stringify(opts.value) : opts.value));
+            if (expires) {
+              if (isNaN(expires)) {
+                expires = expires.replace(/^([0-9]+)(y|M|d|H|h|m|s)$/, function(text, num, unit) {
+                  return toCookieUTCString(toCookieUnitTime(unit, num));
+                });
+              } else if (/^[0-9]{11,13}$/.test(expires) || isDate(expires)) {
+                expires = toCookieUTCString(expires);
+              } else {
+                expires = toCookieUTCString(toCookieUnitTime("d", expires));
+              }
+              opts.expires = expires;
+            }
+            arrayEach(["expires", "path", "domain", "secure"], function(key) {
+              if (!isUndefined(opts[key])) {
+                values.push(opts[key] && key === "secure" ? key : key + "=" + opts[key]);
+              }
+            });
+          }
+          staticDocument.cookie = values.join("; ");
+        });
+        return true;
+      } else {
+        result = {};
+        cookies = staticDocument.cookie;
+        if (cookies) {
+          arrayEach(cookies.split("; "), function(val) {
+            keyIndex = val.indexOf("=");
+            result[staticDecodeURIComponent(val.substring(0, keyIndex))] = staticDecodeURIComponent(val.substring(keyIndex + 1) || "");
+          });
+        }
+        return args.length === 1 ? result[name] : result;
+      }
+    }
+    return false;
+  }
+  function hasCookieItem(value) {
+    return includes(cookieKeys(), value);
+  }
+  function getCookieItem(name) {
+    return cookie(name);
+  }
+  function setCookieItem(name, value, options) {
+    cookie(name, value, options);
+    return cookie;
+  }
+  function removeCookieItem(name, options) {
+    cookie(name, "", assign({ expires: -1 }, setupDefaults.cookies, options));
+  }
+  function cookieKeys() {
+    return keys(cookie());
+  }
+  function cookieJson() {
+    return cookie();
+  }
+  assign(cookie, {
+    has: hasCookieItem,
+    set: setCookieItem,
+    setItem: setCookieItem,
+    get: getCookieItem,
+    getItem: getCookieItem,
+    remove: removeCookieItem,
+    removeItem: removeCookieItem,
+    keys: cookieKeys,
+    getJSON: cookieJson
+  });
+  cookie_1 = cookie;
+  return cookie_1;
+}
+export {
+  requireCookie as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/copyWithin.mjs

@@ -0,0 +1,39 @@
+import { __require as requireIsArray } from "./isArray.mjs";
+var copyWithin_1;
+var hasRequiredCopyWithin;
+function requireCopyWithin() {
+  if (hasRequiredCopyWithin) return copyWithin_1;
+  hasRequiredCopyWithin = 1;
+  var isArray = requireIsArray();
+  function copyWithin(array, target, start, end) {
+    if (isArray(array) && array.copyWithin) {
+      return array.copyWithin(target, start, end);
+    }
+    var replaceIndex, replaceArray;
+    var targetIndex = target >> 0;
+    var startIndex = start >> 0;
+    var len = array.length;
+    var endIndex = arguments.length > 3 ? end >> 0 : len;
+    if (targetIndex < len) {
+      targetIndex = targetIndex >= 0 ? targetIndex : len + targetIndex;
+      if (targetIndex >= 0) {
+        startIndex = startIndex >= 0 ? startIndex : len + startIndex;
+        endIndex = endIndex >= 0 ? endIndex : len + endIndex;
+        if (startIndex < endIndex) {
+          for (replaceIndex = 0, replaceArray = array.slice(startIndex, endIndex); targetIndex < len; targetIndex++) {
+            if (replaceArray.length <= replaceIndex) {
+              break;
+            }
+            array[targetIndex] = replaceArray[replaceIndex++];
+          }
+        }
+      }
+    }
+    return array;
+  }
+  copyWithin_1 = copyWithin;
+  return copyWithin_1;
+}
+export {
+  requireCopyWithin as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/countBy.mjs

@@ -0,0 +1,22 @@
+import { __require as requireGroupBy } from "./groupBy.mjs";
+import { __require as requireObjectEach } from "./objectEach.mjs";
+var countBy_1;
+var hasRequiredCountBy;
+function requireCountBy() {
+  if (hasRequiredCountBy) return countBy_1;
+  hasRequiredCountBy = 1;
+  var groupBy = requireGroupBy();
+  var objectEach = requireObjectEach();
+  function countBy(obj, iterate, context) {
+    var result = groupBy(obj, iterate, context || this);
+    objectEach(result, function(item, key) {
+      result[key] = item.length;
+    });
+    return result;
+  }
+  countBy_1 = countBy;
+  return countBy_1;
+}
+export {
+  requireCountBy as __require
+};