@fecp/mobile 1.1.45 → 1.1.46

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

@@ -0,0 +1,27 @@
+import { __require as requireSlice } from "./slice.mjs";
+var after_1;
+var hasRequiredAfter;
+function requireAfter() {
+  if (hasRequiredAfter) return after_1;
+  hasRequiredAfter = 1;
+  var slice = requireSlice();
+  function after(count, callback, context) {
+    var runCount = 0;
+    var rests = [];
+    return function() {
+      var args = arguments;
+      runCount++;
+      if (runCount <= count) {
+        rests.push(args[0]);
+      }
+      if (runCount >= count) {
+        callback.apply(context, [rests].concat(slice(args)));
+      }
+    };
+  }
+  after_1 = after;
+  return after_1;
+}
+export {
+  requireAfter as __require
+};

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

@@ -0,0 +1,22 @@
+var arrayEach_1;
+var hasRequiredArrayEach;
+function requireArrayEach() {
+  if (hasRequiredArrayEach) return arrayEach_1;
+  hasRequiredArrayEach = 1;
+  function arrayEach(list, iterate, context) {
+    if (list) {
+      if (list.forEach) {
+        list.forEach(iterate, context);
+      } else {
+        for (var index = 0, len = list.length; index < len; index++) {
+          iterate.call(context, list[index], index, list);
+        }
+      }
+    }
+  }
+  arrayEach_1 = arrayEach;
+  return arrayEach_1;
+}
+export {
+  requireArrayEach as __require
+};

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

@@ -0,0 +1,21 @@
+var arrayIndexOf_1;
+var hasRequiredArrayIndexOf;
+function requireArrayIndexOf() {
+  if (hasRequiredArrayIndexOf) return arrayIndexOf_1;
+  hasRequiredArrayIndexOf = 1;
+  function arrayIndexOf(list, val) {
+    if (list.indexOf) {
+      return list.indexOf(val);
+    }
+    for (var index = 0, len = list.length; index < len; index++) {
+      if (val === list[index]) {
+        return index;
+      }
+    }
+  }
+  arrayIndexOf_1 = arrayIndexOf;
+  return arrayIndexOf_1;
+}
+export {
+  requireArrayIndexOf as __require
+};

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
+};