@fecp/mobile 1.1.53 → 1.1.54

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

@@ -0,0 +1,18 @@
+import { __require as requireMap } from "./map.mjs";
+import { __require as requireProperty } from "./property.mjs";
+var pluck_1;
+var hasRequiredPluck;
+function requirePluck() {
+  if (hasRequiredPluck) return pluck_1;
+  hasRequiredPluck = 1;
+  var map = requireMap();
+  var property = requireProperty();
+  function pluck(obj, key) {
+    return map(obj, property(key));
+  }
+  pluck_1 = pluck;
+  return pluck_1;
+}
+export {
+  requirePluck as __require
+};

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

@@ -0,0 +1,18 @@
+import { __require as requireIsNull } from "./isNull.mjs";
+var property_1;
+var hasRequiredProperty;
+function requireProperty() {
+  if (hasRequiredProperty) return property_1;
+  hasRequiredProperty = 1;
+  var isNull = requireIsNull();
+  function property(name, defs) {
+    return function(obj) {
+      return isNull(obj) ? defs : obj[name];
+    };
+  }
+  property_1 = property;
+  return property_1;
+}
+export {
+  requireProperty as __require
+};

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

@@ -0,0 +1,14 @@
+var random_1;
+var hasRequiredRandom;
+function requireRandom() {
+  if (hasRequiredRandom) return random_1;
+  hasRequiredRandom = 1;
+  function random(minVal, maxVal) {
+    return minVal >= maxVal ? minVal : (minVal = minVal >> 0) + Math.round(Math.random() * ((maxVal || 9) - minVal));
+  }
+  random_1 = random;
+  return random_1;
+}
+export {
+  requireRandom as __require
+};

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

@@ -0,0 +1,29 @@
+var range_1;
+var hasRequiredRange;
+function requireRange() {
+  if (hasRequiredRange) return range_1;
+  hasRequiredRange = 1;
+  function range(start, stop, step) {
+    var index, len;
+    var result = [];
+    var args = arguments;
+    if (args.length < 2) {
+      stop = args[0];
+      start = 0;
+    }
+    index = start >> 0;
+    len = stop >> 0;
+    if (index < stop) {
+      step = step >> 0 || 1;
+      for (; index < len; index += step) {
+        result.push(index);
+      }
+    }
+    return result;
+  }
+  range_1 = range;
+  return range_1;
+}
+export {
+  requireRange as __require
+};

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

@@ -0,0 +1,40 @@
+import { __require as requireKeys } from "./keys.mjs";
+var reduce_1;
+var hasRequiredReduce;
+function requireReduce() {
+  if (hasRequiredReduce) return reduce_1;
+  hasRequiredReduce = 1;
+  var keys = requireKeys();
+  function reduce(array, callback, initialValue) {
+    if (array) {
+      var len, reduceMethod;
+      var index = 0;
+      var context = null;
+      var previous = initialValue;
+      var isInitialVal = arguments.length > 2;
+      var keyList = keys(array);
+      if (array.length && array.reduce) {
+        reduceMethod = function() {
+          return callback.apply(context, arguments);
+        };
+        if (isInitialVal) {
+          return array.reduce(reduceMethod, previous);
+        }
+        return array.reduce(reduceMethod);
+      }
+      if (isInitialVal) {
+        index = 1;
+        previous = array[keyList[0]];
+      }
+      for (len = keyList.length; index < len; index++) {
+        previous = callback.call(context, previous, array[keyList[index]], index, array);
+      }
+      return previous;
+    }
+  }
+  reduce_1 = reduce;
+  return reduce_1;
+}
+export {
+  requireReduce as __require
+};

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

@@ -0,0 +1,63 @@
+import { __require as requireHelperDeleteProperty } from "./helperDeleteProperty.mjs";
+import { __require as requireIsFunction } from "./isFunction.mjs";
+import { __require as requireIsArray } from "./isArray.mjs";
+import { __require as requireEach } from "./each.mjs";
+import { __require as requireArrayEach } from "./arrayEach.mjs";
+import { __require as requireLastEach } from "./lastEach.mjs";
+import { __require as requireClear } from "./clear.mjs";
+import { __require as requireEqNull } from "./eqNull.mjs";
+var remove_1;
+var hasRequiredRemove;
+function requireRemove() {
+  if (hasRequiredRemove) return remove_1;
+  hasRequiredRemove = 1;
+  var helperDeleteProperty = requireHelperDeleteProperty();
+  var isFunction = requireIsFunction();
+  var isArray = requireIsArray();
+  var each = requireEach();
+  var arrayEach = requireArrayEach();
+  var lastEach = requireLastEach();
+  var clear = requireClear();
+  var eqNull = requireEqNull();
+  function pluckProperty(name) {
+    return function(obj, key) {
+      return key === name;
+    };
+  }
+  function remove(obj, iterate, context) {
+    if (obj) {
+      if (!eqNull(iterate)) {
+        var removeKeys = [];
+        var rest = [];
+        if (!isFunction(iterate)) {
+          iterate = pluckProperty(iterate);
+        }
+        each(obj, function(item, index, rest2) {
+          if (iterate.call(context, item, index, rest2)) {
+            removeKeys.push(index);
+          }
+        });
+        if (isArray(obj)) {
+          lastEach(removeKeys, function(item, key) {
+            rest.push(obj[item]);
+            obj.splice(item, 1);
+          });
+        } else {
+          rest = {};
+          arrayEach(removeKeys, function(key) {
+            rest[key] = obj[key];
+            helperDeleteProperty(obj, key);
+          });
+        }
+        return rest;
+      }
+      return clear(obj);
+    }
+    return obj;
+  }
+  remove_1 = remove;
+  return remove_1;
+}
+export {
+  requireRemove as __require
+};

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

@@ -0,0 +1,18 @@
+import { __require as requireToValueString } from "./toValueString.mjs";
+import { __require as requireHelperStringRepeat } from "./helperStringRepeat.mjs";
+var repeat_1;
+var hasRequiredRepeat;
+function requireRepeat() {
+  if (hasRequiredRepeat) return repeat_1;
+  hasRequiredRepeat = 1;
+  var toValueString = requireToValueString();
+  var helperStringRepeat = requireHelperStringRepeat();
+  function repeat(str, count) {
+    return helperStringRepeat(toValueString(str), count);
+  }
+  repeat_1 = repeat;
+  return repeat_1;
+}
+export {
+  requireRepeat as __require
+};

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

@@ -0,0 +1,14 @@
+import { __require as requireHelperCreateMathNumber } from "./helperCreateMathNumber.mjs";
+var round_1;
+var hasRequiredRound;
+function requireRound() {
+  if (hasRequiredRound) return round_1;
+  hasRequiredRound = 1;
+  var helperCreateMathNumber = requireHelperCreateMathNumber();
+  var round = helperCreateMathNumber("round");
+  round_1 = round;
+  return round_1;
+}
+export {
+  requireRound as __require
+};

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

@@ -0,0 +1,23 @@
+import { __require as requireShuffle } from "./shuffle.mjs";
+var sample_1;
+var hasRequiredSample;
+function requireSample() {
+  if (hasRequiredSample) return sample_1;
+  hasRequiredSample = 1;
+  var shuffle = requireShuffle();
+  function sample(array, number) {
+    var result = shuffle(array);
+    if (arguments.length <= 1) {
+      return result[0];
+    }
+    if (number < result.length) {
+      result.length = number || 0;
+    }
+    return result;
+  }
+  sample_1 = sample;
+  return sample_1;
+}
+export {
+  requireSample as __require
+};

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

@@ -0,0 +1,51 @@
+import { __require as requireHelperCreateTreeFunc } from "./helperCreateTreeFunc.mjs";
+import { __require as requireArrayEach } from "./arrayEach.mjs";
+import { __require as requireAssign } from "./assign.mjs";
+var searchTree_1;
+var hasRequiredSearchTree;
+function requireSearchTree() {
+  if (hasRequiredSearchTree) return searchTree_1;
+  hasRequiredSearchTree = 1;
+  var helperCreateTreeFunc = requireHelperCreateTreeFunc();
+  var arrayEach = requireArrayEach();
+  var assign = requireAssign();
+  function searchTreeItem(matchParent, parent, obj, iterate, context, path, node, parseChildren, opts) {
+    var paths, nodes, rest, isMatch, hasChild;
+    var rests = [];
+    var hasOriginal = opts.original;
+    var sourceData = opts.data;
+    var mapChildren = opts.mapChildren || parseChildren;
+    var isEvery = opts.isEvery;
+    arrayEach(obj, function(item, index) {
+      paths = path.concat(["" + index]);
+      nodes = node.concat([item]);
+      isMatch = matchParent && !isEvery || iterate.call(context, item, index, obj, paths, parent, nodes);
+      hasChild = parseChildren && item[parseChildren];
+      if (isMatch || hasChild) {
+        if (hasOriginal) {
+          rest = item;
+        } else {
+          rest = assign({}, item);
+          if (sourceData) {
+            rest[sourceData] = item;
+          }
+        }
+        rest[mapChildren] = searchTreeItem(isMatch, item, item[parseChildren], iterate, context, paths, nodes, parseChildren, opts);
+        if (isMatch || rest[mapChildren].length) {
+          rests.push(rest);
+        }
+      } else if (isMatch) {
+        rests.push(rest);
+      }
+    });
+    return rests;
+  }
+  var searchTree = helperCreateTreeFunc(function(parent, obj, iterate, context, path, nodes, parseChildren, opts) {
+    return searchTreeItem(0, parent, obj, iterate, context, path, nodes, parseChildren, opts);
+  });
+  searchTree_1 = searchTree;
+  return searchTree_1;
+}
+export {
+  requireSearchTree as __require
+};

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

@@ -0,0 +1,51 @@
+import { __require as requireStaticEncodeURIComponent } from "./staticEncodeURIComponent.mjs";
+import { __require as requireEach } from "./each.mjs";
+import { __require as requireIsArray } from "./isArray.mjs";
+import { __require as requireIsNull } from "./isNull.mjs";
+import { __require as requireIsUndefined } from "./isUndefined.mjs";
+import { __require as requireIsPlainObject } from "./isPlainObject.mjs";
+var serialize_1;
+var hasRequiredSerialize;
+function requireSerialize() {
+  if (hasRequiredSerialize) return serialize_1;
+  hasRequiredSerialize = 1;
+  var staticEncodeURIComponent = requireStaticEncodeURIComponent();
+  var each = requireEach();
+  var isArray = requireIsArray();
+  var isNull = requireIsNull();
+  var isUndefined = requireIsUndefined();
+  var isPlainObject = requireIsPlainObject();
+  function stringifyParams(resultVal, resultKey, isArr) {
+    var _arr;
+    var result = [];
+    each(resultVal, function(item, key) {
+      _arr = isArray(item);
+      if (isPlainObject(item) || _arr) {
+        result = result.concat(stringifyParams(item, resultKey + "[" + key + "]", _arr));
+      } else {
+        result.push(staticEncodeURIComponent(resultKey + "[" + (isArr ? "" : key) + "]") + "=" + staticEncodeURIComponent(isNull(item) ? "" : item));
+      }
+    });
+    return result;
+  }
+  function serialize(query) {
+    var _arr;
+    var params = [];
+    each(query, function(item, key) {
+      if (!isUndefined(item)) {
+        _arr = isArray(item);
+        if (isPlainObject(item) || _arr) {
+          params = params.concat(stringifyParams(item, key, _arr));
+        } else {
+          params.push(staticEncodeURIComponent(key) + "=" + staticEncodeURIComponent(isNull(item) ? "" : item));
+        }
+      }
+    });
+    return params.join("&").replace(/%20/g, "+");
+  }
+  serialize_1 = serialize;
+  return serialize_1;
+}
+export {
+  requireSerialize as __require
+};

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

@@ -0,0 +1,88 @@
+import { __require as requireStaticParseInt } from "./staticParseInt.mjs";
+import { __require as requireHelperGetHGSKeys } from "./helperGetHGSKeys.mjs";
+import { __require as requireHelperCheckCopyKey } from "./helperCheckCopyKey.mjs";
+import { __require as requireHasOwnProp } from "./hasOwnProp.mjs";
+var set_1;
+var hasRequiredSet;
+function requireSet() {
+  if (hasRequiredSet) return set_1;
+  hasRequiredSet = 1;
+  var staticParseInt = requireStaticParseInt();
+  var helperGetHGSKeys = requireHelperGetHGSKeys();
+  var helperCheckCopyKey = requireHelperCheckCopyKey();
+  var hasOwnProp = requireHasOwnProp();
+  var sKeyRE = /(.+)?\[(\d+)\]$/;
+  function setDeepProps(obj, key, isEnd, nextKey, value) {
+    if (obj[key]) {
+      if (isEnd) {
+        obj[key] = value;
+      }
+    } else {
+      var index;
+      var rest;
+      var currMatchs = key ? key.match(sKeyRE) : null;
+      if (isEnd) {
+        rest = value;
+      } else {
+        var nextMatchs = nextKey ? nextKey.match(sKeyRE) : null;
+        if (nextMatchs && !nextMatchs[1]) {
+          rest = new Array(staticParseInt(nextMatchs[2]) + 1);
+        } else {
+          rest = {};
+        }
+      }
+      if (currMatchs) {
+        if (currMatchs[1]) {
+          index = staticParseInt(currMatchs[2]);
+          if (obj[currMatchs[1]]) {
+            if (isEnd) {
+              obj[currMatchs[1]][index] = rest;
+            } else {
+              if (obj[currMatchs[1]][index]) {
+                rest = obj[currMatchs[1]][index];
+              } else {
+                obj[currMatchs[1]][index] = rest;
+              }
+            }
+          } else {
+            obj[currMatchs[1]] = new Array(index + 1);
+            obj[currMatchs[1]][index] = rest;
+          }
+        } else {
+          obj[currMatchs[2]] = rest;
+        }
+      } else {
+        obj[key] = rest;
+      }
+      return rest;
+    }
+    return obj[key];
+  }
+  function set(obj, property, value) {
+    if (obj && helperCheckCopyKey(property)) {
+      if ((obj[property] || hasOwnProp(obj, property)) && !isPrototypePolluted(property)) {
+        obj[property] = value;
+      } else {
+        var rest = obj;
+        var props = helperGetHGSKeys(property);
+        var len = props.length;
+        for (var index = 0; index < len; index++) {
+          if (isPrototypePolluted(props[index])) {
+            continue;
+          }
+          var isEnd = index === len - 1;
+          rest = setDeepProps(rest, props[index], isEnd, isEnd ? null : props[index + 1], value);
+        }
+      }
+    }
+    return obj;
+  }
+  function isPrototypePolluted(key) {
+    return key === "__proto__" || key === "constructor" || key === "prototype";
+  }
+  set_1 = set;
+  return set_1;
+}
+export {
+  requireSet as __require
+};

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

@@ -0,0 +1,24 @@
+var setupDefaults_1;
+var hasRequiredSetupDefaults;
+function requireSetupDefaults() {
+  if (hasRequiredSetupDefaults) return setupDefaults_1;
+  hasRequiredSetupDefaults = 1;
+  var setupDefaults = {
+    keyId: 1,
+    cookies: {
+      path: "/"
+    },
+    treeOptions: {
+      parentKey: "parentId",
+      key: "id",
+      children: "children"
+    },
+    parseDateFormat: "yyyy-MM-dd HH:mm:ss",
+    firstDayOfWeek: 1
+  };
+  setupDefaults_1 = setupDefaults;
+  return setupDefaults_1;
+}
+export {
+  requireSetupDefaults as __require
+};

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

@@ -0,0 +1,27 @@
+import { __require as requireRandom } from "./random.mjs";
+import { __require as requireValues } from "./values.mjs";
+var shuffle_1;
+var hasRequiredShuffle;
+function requireShuffle() {
+  if (hasRequiredShuffle) return shuffle_1;
+  hasRequiredShuffle = 1;
+  var random = requireRandom();
+  var values = requireValues();
+  function shuffle(array) {
+    var index;
+    var result = [];
+    var list = values(array);
+    var len = list.length - 1;
+    for (; len >= 0; len--) {
+      index = len > 0 ? random(0, len) : 0;
+      result.push(list[index]);
+      list.splice(index, 1);
+    }
+    return result;
+  }
+  shuffle_1 = shuffle;
+  return shuffle_1;
+}
+export {
+  requireShuffle as __require
+};

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

@@ -0,0 +1,28 @@
+import { __require as requireToNumber } from "./toNumber.mjs";
+var slice_1;
+var hasRequiredSlice;
+function requireSlice() {
+  if (hasRequiredSlice) return slice_1;
+  hasRequiredSlice = 1;
+  var toNumber = requireToNumber();
+  function slice(array, startIndex, endIndex) {
+    var result = [];
+    var argsSize = arguments.length;
+    if (array) {
+      startIndex = argsSize >= 2 ? toNumber(startIndex) : 0;
+      endIndex = argsSize >= 3 ? toNumber(endIndex) : array.length;
+      if (array.slice) {
+        return array.slice(startIndex, endIndex);
+      }
+      for (; startIndex < endIndex; startIndex++) {
+        result.push(array[startIndex]);
+      }
+    }
+    return result;
+  }
+  slice_1 = slice;
+  return slice_1;
+}
+export {
+  requireSlice as __require
+};

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

@@ -0,0 +1,14 @@
+import { __require as requireHelperCreateIterateHandle } from "./helperCreateIterateHandle.mjs";
+var some_1;
+var hasRequiredSome;
+function requireSome() {
+  if (hasRequiredSome) return some_1;
+  hasRequiredSome = 1;
+  var helperCreateIterateHandle = requireHelperCreateIterateHandle();
+  var some = helperCreateIterateHandle("some", 1, 0, true, false);
+  some_1 = some;
+  return some_1;
+}
+export {
+  requireSome as __require
+};

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

@@ -0,0 +1,14 @@
+import { __require as requireOrderBy } from "./orderBy.mjs";
+var sortBy_1;
+var hasRequiredSortBy;
+function requireSortBy() {
+  if (hasRequiredSortBy) return sortBy_1;
+  hasRequiredSortBy = 1;
+  var orderBy = requireOrderBy();
+  var sortBy = orderBy;
+  sortBy_1 = sortBy;
+  return sortBy_1;
+}
+export {
+  requireSortBy as __require
+};

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

@@ -0,0 +1,17 @@
+import { __require as requireToValueString } from "./toValueString.mjs";
+var startsWith_1;
+var hasRequiredStartsWith;
+function requireStartsWith() {
+  if (hasRequiredStartsWith) return startsWith_1;
+  hasRequiredStartsWith = 1;
+  var toValueString = requireToValueString();
+  function startsWith(str, val, startIndex) {
+    var rest = toValueString(str);
+    return (arguments.length === 1 ? rest : rest.substring(startIndex)).indexOf(val) === 0;
+  }
+  startsWith_1 = startsWith;
+  return startsWith_1;
+}
+export {
+  requireStartsWith as __require
+};

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

@@ -0,0 +1,12 @@
+var staticDayTime_1;
+var hasRequiredStaticDayTime;
+function requireStaticDayTime() {
+  if (hasRequiredStaticDayTime) return staticDayTime_1;
+  hasRequiredStaticDayTime = 1;
+  var staticDayTime = 864e5;
+  staticDayTime_1 = staticDayTime;
+  return staticDayTime_1;
+}
+export {
+  requireStaticDayTime as __require
+};

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

@@ -0,0 +1,12 @@
+var staticDecodeURIComponent_1;
+var hasRequiredStaticDecodeURIComponent;
+function requireStaticDecodeURIComponent() {
+  if (hasRequiredStaticDecodeURIComponent) return staticDecodeURIComponent_1;
+  hasRequiredStaticDecodeURIComponent = 1;
+  var staticDecodeURIComponent = decodeURIComponent;
+  staticDecodeURIComponent_1 = staticDecodeURIComponent;
+  return staticDecodeURIComponent_1;
+}
+export {
+  requireStaticDecodeURIComponent as __require
+};

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

@@ -0,0 +1,14 @@
+import { __require as requireStaticStrUndefined } from "./staticStrUndefined.mjs";
+var staticDocument_1;
+var hasRequiredStaticDocument;
+function requireStaticDocument() {
+  if (hasRequiredStaticDocument) return staticDocument_1;
+  hasRequiredStaticDocument = 1;
+  var staticStrUndefined = requireStaticStrUndefined();
+  var staticDocument = typeof document === staticStrUndefined ? 0 : document;
+  staticDocument_1 = staticDocument;
+  return staticDocument_1;
+}
+export {
+  requireStaticDocument as __require
+};

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

@@ -0,0 +1,12 @@
+var staticEncodeURIComponent_1;
+var hasRequiredStaticEncodeURIComponent;
+function requireStaticEncodeURIComponent() {
+  if (hasRequiredStaticEncodeURIComponent) return staticEncodeURIComponent_1;
+  hasRequiredStaticEncodeURIComponent = 1;
+  var staticEncodeURIComponent = encodeURIComponent;
+  staticEncodeURIComponent_1 = staticEncodeURIComponent;
+  return staticEncodeURIComponent_1;
+}
+export {
+  requireStaticEncodeURIComponent as __require
+};

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

@@ -0,0 +1,19 @@
+var staticEscapeMap_1;
+var hasRequiredStaticEscapeMap;
+function requireStaticEscapeMap() {
+  if (hasRequiredStaticEscapeMap) return staticEscapeMap_1;
+  hasRequiredStaticEscapeMap = 1;
+  var staticEscapeMap = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#x27;",
+    "`": "&#x60;"
+  };
+  staticEscapeMap_1 = staticEscapeMap;
+  return staticEscapeMap_1;
+}
+export {
+  requireStaticEscapeMap as __require
+};

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

@@ -0,0 +1,12 @@
+var staticHGKeyRE_1;
+var hasRequiredStaticHGKeyRE;
+function requireStaticHGKeyRE() {
+  if (hasRequiredStaticHGKeyRE) return staticHGKeyRE_1;
+  hasRequiredStaticHGKeyRE = 1;
+  var staticHGKeyRE = /(.+)?\[(\d+)\]$/;
+  staticHGKeyRE_1 = staticHGKeyRE;
+  return staticHGKeyRE_1;
+}
+export {
+  requireStaticHGKeyRE as __require
+};

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

@@ -0,0 +1,14 @@
+import { __require as requireStaticStrUndefined } from "./staticStrUndefined.mjs";
+var staticLocation_1;
+var hasRequiredStaticLocation;
+function requireStaticLocation() {
+  if (hasRequiredStaticLocation) return staticLocation_1;
+  hasRequiredStaticLocation = 1;
+  var staticStrUndefined = requireStaticStrUndefined();
+  var staticLocation = typeof location === staticStrUndefined ? 0 : location;
+  staticLocation_1 = staticLocation;
+  return staticLocation_1;
+}
+export {
+  requireStaticLocation as __require
+};