@fecp/mobile 1.1.45 → 1.1.47

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/after.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const slice = require("./slice.js");
+var after_1;
+var hasRequiredAfter;
+function requireAfter() {
+  if (hasRequiredAfter) return after_1;
+  hasRequiredAfter = 1;
+  var slice$1 = slice.__require();
+  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$1(args)));
+      }
+    };
+  }
+  after_1 = after;
+  return after_1;
+}
+exports.__require = requireAfter;

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/arrayEach.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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;
+}
+exports.__require = requireArrayEach;

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/arrayIndexOf.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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;
+}
+exports.__require = requireArrayIndexOf;

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/arrayLastIndexOf.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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;
+}
+exports.__require = requireArrayLastIndexOf;

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/assign.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const arrayEach = require("./arrayEach.js");
+const keys = require("./keys.js");
+const isArray = require("./isArray.js");
+const clone = require("./clone.js");
+var assign_1;
+var hasRequiredAssign;
+function requireAssign() {
+  if (hasRequiredAssign) return assign_1;
+  hasRequiredAssign = 1;
+  var arrayEach$1 = arrayEach.__require();
+  var keys$1 = keys.__require();
+  var isArray$1 = isArray.__require();
+  var clone$1 = clone.__require();
+  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$1(keys$1(args[index]), isClone ? function(key) {
+        destination[key] = clone$1(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$1(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;
+}
+exports.__require = requireAssign;

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/before.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const slice = require("./slice.js");
+var before_1;
+var hasRequiredBefore;
+function requireBefore() {
+  if (hasRequiredBefore) return before_1;
+  hasRequiredBefore = 1;
+  var slice$1 = slice.__require();
+  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$1(args)));
+      }
+    };
+  }
+  before_1 = before;
+  return before_1;
+}
+exports.__require = requireBefore;

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/bind.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const slice = require("./slice.js");
+var bind_1;
+var hasRequiredBind;
+function requireBind() {
+  if (hasRequiredBind) return bind_1;
+  hasRequiredBind = 1;
+  var slice$1 = slice.__require();
+  function bind(callback, context) {
+    var args = slice$1(arguments, 2);
+    return function() {
+      return callback.apply(context, slice$1(arguments).concat(args));
+    };
+  }
+  bind_1 = bind;
+  return bind_1;
+}
+exports.__require = requireBind;

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/browse.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const staticStrUndefined = require("./staticStrUndefined.js");
+const staticDocument = require("./staticDocument.js");
+const staticWindow = require("./staticWindow.js");
+const assign = require("./assign.js");
+const arrayEach = require("./arrayEach.js");
+var browse_1;
+var hasRequiredBrowse;
+function requireBrowse() {
+  if (hasRequiredBrowse) return browse_1;
+  hasRequiredBrowse = 1;
+  var staticStrUndefined$1 = staticStrUndefined.__require();
+  var staticDocument$1 = staticDocument.__require();
+  var staticWindow$1 = staticWindow.__require();
+  var assign$1 = assign.__require();
+  var arrayEach$1 = arrayEach.__require();
+  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$1
+    };
+    if (!staticWindow$1 && typeof process !== staticStrUndefined$1) {
+      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$1.body || staticDocument$1.documentElement;
+        arrayEach$1(["webkit", "khtml", "moz", "ms", "o"], function(core) {
+          result["-" + core] = !!$body[core + "MatchesSelector"];
+        });
+      }
+      try {
+        isLocalStorage = isBrowseStorage(staticWindow$1.localStorage);
+      } catch (e) {
+      }
+      try {
+        isSessionStorage = isBrowseStorage(staticWindow$1.sessionStorage);
+      } catch (e) {
+      }
+      assign$1(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;
+}
+exports.__require = requireBrowse;

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/camelCase.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const toValueString = require("./toValueString.js");
+const helperStringSubstring = require("./helperStringSubstring.js");
+const helperStringUpperCase = require("./helperStringUpperCase.js");
+const helperStringLowerCase = require("./helperStringLowerCase.js");
+var camelCase_1;
+var hasRequiredCamelCase;
+function requireCamelCase() {
+  if (hasRequiredCamelCase) return camelCase_1;
+  hasRequiredCamelCase = 1;
+  var toValueString$1 = toValueString.__require();
+  var helperStringSubstring$1 = helperStringSubstring.__require();
+  var helperStringUpperCase$1 = helperStringUpperCase.__require();
+  var helperStringLowerCase$1 = helperStringLowerCase.__require();
+  var camelCacheMaps = {};
+  function camelCase(str) {
+    str = toValueString$1(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$1(upper);
+      if (index) {
+        if (upperLen > 2 && index + upperLen < strLen) {
+          return helperStringUpperCase$1(helperStringSubstring$1(upper, 0, 1)) + helperStringSubstring$1(upper, 1, upperLen - 1) + helperStringUpperCase$1(helperStringSubstring$1(upper, upperLen - 1, upperLen));
+        }
+        return helperStringUpperCase$1(helperStringSubstring$1(upper, 0, 1)) + helperStringSubstring$1(upper, 1, upperLen);
+      } else {
+        if (upperLen > 1 && index + upperLen < strLen) {
+          return helperStringSubstring$1(upper, 0, upperLen - 1) + helperStringUpperCase$1(helperStringSubstring$1(upper, upperLen - 1, upperLen));
+        }
+      }
+      return upper;
+    }).replace(/(-[a-zA-Z])/g, function(text, upper) {
+      return helperStringUpperCase$1(helperStringSubstring$1(upper, 1, upper.length));
+    });
+    camelCacheMaps[str] = rest;
+    return rest;
+  }
+  camelCase_1 = camelCase;
+  return camelCase_1;
+}
+exports.__require = requireCamelCase;

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/ceil.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const helperCreateMathNumber = require("./helperCreateMathNumber.js");
+var ceil_1;
+var hasRequiredCeil;
+function requireCeil() {
+  if (hasRequiredCeil) return ceil_1;
+  hasRequiredCeil = 1;
+  var helperCreateMathNumber$1 = helperCreateMathNumber.__require();
+  var ceil = helperCreateMathNumber$1("ceil");
+  ceil_1 = ceil;
+  return ceil_1;
+}
+exports.__require = requireCeil;

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/chunk.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isArray = require("./isArray.js");
+var chunk_1;
+var hasRequiredChunk;
+function requireChunk() {
+  if (hasRequiredChunk) return chunk_1;
+  hasRequiredChunk = 1;
+  var isArray$1 = isArray.__require();
+  function chunk(array, size) {
+    var index;
+    var result = [];
+    var arrLen = size >> 0 || 1;
+    if (isArray$1(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;
+}
+exports.__require = requireChunk;

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/clear.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const helperDeleteProperty = require("./helperDeleteProperty.js");
+const isPlainObject = require("./isPlainObject.js");
+const isObject = require("./isObject.js");
+const isArray = require("./isArray.js");
+const isNull = require("./isNull.js");
+const assign = require("./assign.js");
+const objectEach = require("./objectEach.js");
+var clear_1;
+var hasRequiredClear;
+function requireClear() {
+  if (hasRequiredClear) return clear_1;
+  hasRequiredClear = 1;
+  var helperDeleteProperty$1 = helperDeleteProperty.__require();
+  var isPlainObject$1 = isPlainObject.__require();
+  var isObject$1 = isObject.__require();
+  var isArray$1 = isArray.__require();
+  var isNull$1 = isNull.__require();
+  var assign$1 = assign.__require();
+  var objectEach$1 = objectEach.__require();
+  function clear(obj, defs, assigns) {
+    if (obj) {
+      var len;
+      var isDefs = arguments.length > 1 && (isNull$1(defs) || !isObject$1(defs));
+      var extds = isDefs ? assigns : defs;
+      if (isPlainObject$1(obj)) {
+        objectEach$1(obj, isDefs ? function(val, key) {
+          obj[key] = defs;
+        } : function(val, key) {
+          helperDeleteProperty$1(obj, key);
+        });
+        if (extds) {
+          assign$1(obj, extds);
+        }
+      } else if (isArray$1(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;
+}
+exports.__require = requireClear;

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/clone.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const staticObjectToString = require("./staticObjectToString.js");
+const objectEach = require("./objectEach.js");
+const arrayEach = require("./arrayEach.js");
+var clone_1;
+var hasRequiredClone;
+function requireClone() {
+  if (hasRequiredClone) return clone_1;
+  hasRequiredClone = 1;
+  var objectToString = staticObjectToString.__require();
+  var objectEach$1 = objectEach.__require();
+  var arrayEach$1 = arrayEach.__require();
+  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$1(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$1(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;
+}
+exports.__require = requireClone;

package/lib/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/commafy.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const setupDefaults = require("./setupDefaults.js");
+const round = require("./round.js");
+const ceil = require("./ceil.js");
+const floor = require("./floor.js");
+const isNumber = require("./isNumber.js");
+const toValueString = require("./toValueString.js");
+const toFixed = require("./toFixed.js");
+const toNumberString = require("./toNumberString.js");
+const assign = require("./assign.js");
+var commafy_1;
+var hasRequiredCommafy;
+function requireCommafy() {
+  if (hasRequiredCommafy) return commafy_1;
+  hasRequiredCommafy = 1;
+  var setupDefaults$1 = setupDefaults.__require();
+  var round$1 = round.__require();
+  var ceil$1 = ceil.__require();
+  var floor$1 = floor.__require();
+  var isNumber$1 = isNumber.__require();
+  var toValueString$1 = toValueString.__require();
+  var toFixed$1 = toFixed.__require();
+  var toNumberString$1 = toNumberString.__require();
+  var assign$1 = assign.__require();
+  function commafy(num, options) {
+    var opts = assign$1({}, setupDefaults$1.commafyOptions, options);
+    var optDigits = opts.digits;
+    var isNum = isNumber$1(num);
+    var rest, result, isNegative, intStr, floatStr;
+    if (isNum) {
+      rest = (opts.ceil ? ceil$1 : opts.floor ? floor$1 : round$1)(num, optDigits);
+      result = toNumberString$1(optDigits ? toFixed$1(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$1(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;
+}
+exports.__require = requireCommafy;