@fecp/mobile 1.1.45 → 1.1.46

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

@@ -0,0 +1,51 @@
+import { __require as requireHelperStringRepeat } from "./helperStringRepeat.mjs";
+import { __require as requireHelperNumberOffsetPoint } from "./helperNumberOffsetPoint.mjs";
+var toNumberString_1;
+var hasRequiredToNumberString;
+function requireToNumberString() {
+  if (hasRequiredToNumberString) return toNumberString_1;
+  hasRequiredToNumberString = 1;
+  var helperStringRepeat = requireHelperStringRepeat();
+  var helperNumberOffsetPoint = requireHelperNumberOffsetPoint();
+  function toNumberString(num) {
+    var rest = "" + num;
+    var scienceMatchs = rest.match(/^([-+]?)((\d+)|((\d+)?[.](\d+)?))e([-+]{1})([0-9]+)$/);
+    if (scienceMatchs) {
+      var isNegative = num < 0;
+      var absFlag = isNegative ? "-" : "";
+      var intNumStr = scienceMatchs[3] || "";
+      var dIntNumStr = scienceMatchs[5] || "";
+      var dFloatNumStr = scienceMatchs[6] || "";
+      var sciencFlag = scienceMatchs[7];
+      var scienceNumStr = scienceMatchs[8];
+      var floatOffsetIndex = scienceNumStr - dFloatNumStr.length;
+      var intOffsetIndex = scienceNumStr - intNumStr.length;
+      var dIntOffsetIndex = scienceNumStr - dIntNumStr.length;
+      if (sciencFlag === "+") {
+        if (intNumStr) {
+          return absFlag + intNumStr + helperStringRepeat("0", scienceNumStr);
+        }
+        if (floatOffsetIndex > 0) {
+          return absFlag + dIntNumStr + dFloatNumStr + helperStringRepeat("0", floatOffsetIndex);
+        }
+        return absFlag + dIntNumStr + helperNumberOffsetPoint(dFloatNumStr, scienceNumStr);
+      }
+      if (intNumStr) {
+        if (intOffsetIndex > 0) {
+          return absFlag + "0." + helperStringRepeat("0", Math.abs(intOffsetIndex)) + intNumStr;
+        }
+        return absFlag + helperNumberOffsetPoint(intNumStr, intOffsetIndex);
+      }
+      if (dIntOffsetIndex > 0) {
+        return absFlag + "0." + helperStringRepeat("0", Math.abs(dIntOffsetIndex)) + dIntNumStr + dFloatNumStr;
+      }
+      return absFlag + helperNumberOffsetPoint(dIntNumStr, dIntOffsetIndex) + dFloatNumStr;
+    }
+    return rest;
+  }
+  toNumberString_1 = toNumberString;
+  return toNumberString_1;
+}
+export {
+  requireToNumberString as __require
+};

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

@@ -0,0 +1,159 @@
+import { __require as requireStaticParseInt } from "./staticParseInt.mjs";
+import { __require as requireHelperGetUTCDateTime } from "./helperGetUTCDateTime.mjs";
+import { __require as requireHelperGetDateTime } from "./helperGetDateTime.mjs";
+import { __require as requireIsString } from "./isString.mjs";
+import { __require as requireIsDate } from "./isDate.mjs";
+var toStringDate_1;
+var hasRequiredToStringDate;
+function requireToStringDate() {
+  if (hasRequiredToStringDate) return toStringDate_1;
+  hasRequiredToStringDate = 1;
+  var staticParseInt = requireStaticParseInt();
+  var helperGetUTCDateTime = requireHelperGetUTCDateTime();
+  var helperGetDateTime = requireHelperGetDateTime();
+  var isString = requireIsString();
+  var isDate = requireIsDate();
+  function getParseRule(txt) {
+    return "(\\d{" + txt + "})";
+  }
+  function toParseMs(num) {
+    if (num < 10) {
+      return num * 100;
+    } else if (num < 100) {
+      return num * 10;
+    }
+    return num;
+  }
+  function toParseNum(num) {
+    return isNaN(num) ? num : staticParseInt(num);
+  }
+  var d2 = getParseRule(2);
+  var d1or2 = getParseRule("1,2");
+  var d1or7 = getParseRule("1,7");
+  var d3or4 = getParseRule("3,4");
+  var place = ".{1}";
+  var d1Or2RE = place + d1or2;
+  var dzZ = "(([zZ])|([-+]\\d{2}:?\\d{2}))";
+  var defaulParseStrs = [d3or4, d1Or2RE, d1Or2RE, d1Or2RE, d1Or2RE, d1Or2RE, place + d1or7, dzZ];
+  var defaulParseREs = [];
+  for (var len = defaulParseStrs.length - 1; len >= 0; len--) {
+    var rule = "";
+    for (var i = 0; i < len + 1; i++) {
+      rule += defaulParseStrs[i];
+    }
+    defaulParseREs.push(new RegExp("^" + rule + "$"));
+  }
+  function parseDefaultRules(str) {
+    var matchRest, resMaps = {};
+    for (var i2 = 0, dfrLen = defaulParseREs.length; i2 < dfrLen; i2++) {
+      matchRest = str.match(defaulParseREs[i2]);
+      if (matchRest) {
+        resMaps.y = matchRest[1];
+        resMaps.M = matchRest[2];
+        resMaps.d = matchRest[3];
+        resMaps.H = matchRest[4];
+        resMaps.m = matchRest[5];
+        resMaps.s = matchRest[6];
+        resMaps.S = matchRest[7];
+        resMaps.Z = matchRest[8];
+        break;
+      }
+    }
+    return resMaps;
+  }
+  var customParseStrs = [
+    ["yyyy", d3or4],
+    ["yy", d2],
+    ["MM", d2],
+    ["M", d1or2],
+    ["dd", d2],
+    ["d", d1or2],
+    ["HH", d2],
+    ["H", d1or2],
+    ["mm", d2],
+    ["m", d1or2],
+    ["ss", d2],
+    ["s", d1or2],
+    ["SSS", getParseRule(3)],
+    ["S", d1or7],
+    ["Z", dzZ]
+  ];
+  var parseRuleMaps = {};
+  var parseRuleKeys = ["\\[([^\\]]+)\\]"];
+  for (var i = 0; i < customParseStrs.length; i++) {
+    var itemRule = customParseStrs[i];
+    parseRuleMaps[itemRule[0]] = itemRule[1] + "?";
+    parseRuleKeys.push(itemRule[0]);
+  }
+  var customParseRes = new RegExp(parseRuleKeys.join("|"), "g");
+  var cacheFormatMaps = {};
+  function parseCustomRules(str, format) {
+    var cacheItem = cacheFormatMaps[format];
+    if (!cacheItem) {
+      var posIndexs = [];
+      var re = format.replace(/([$(){}*+.?\\^|])/g, "\\$1").replace(customParseRes, function(text, val) {
+        var firstChar = text.charAt(0);
+        if (firstChar === "[") {
+          return val;
+        }
+        posIndexs.push(firstChar);
+        return parseRuleMaps[text];
+      });
+      cacheItem = cacheFormatMaps[format] = {
+        _i: posIndexs,
+        _r: new RegExp(re)
+      };
+    }
+    var resMaps = {};
+    var matchRest = str.match(cacheItem._r);
+    if (matchRest) {
+      var _i = cacheItem._i;
+      for (var i2 = 1, len2 = matchRest.length; i2 < len2; i2++) {
+        resMaps[_i[i2 - 1]] = matchRest[i2];
+      }
+      return resMaps;
+    }
+    return resMaps;
+  }
+  function parseTimeZone(resMaps) {
+    if (/^[zZ]/.test(resMaps.Z)) {
+      return new Date(helperGetUTCDateTime(resMaps));
+    } else {
+      var matchRest = resMaps.Z.match(/([-+])(\d{2}):?(\d{2})/);
+      if (matchRest) {
+        return new Date(helperGetUTCDateTime(resMaps) - (matchRest[1] === "-" ? -1 : 1) * staticParseInt(matchRest[2]) * 36e5 + staticParseInt(matchRest[3]) * 6e4);
+      }
+    }
+    return /* @__PURE__ */ new Date("");
+  }
+  function toStringDate(str, format) {
+    if (str) {
+      var isDType = isDate(str);
+      if (isDType || !format && /^[0-9]{11,15}$/.test(str)) {
+        return new Date(isDType ? helperGetDateTime(str) : staticParseInt(str));
+      }
+      if (isString(str)) {
+        var resMaps = format ? parseCustomRules(str, format) : parseDefaultRules(str);
+        if (resMaps.y) {
+          if (resMaps.M) {
+            resMaps.M = toParseNum(resMaps.M) - 1;
+          }
+          if (resMaps.S) {
+            resMaps.S = toParseMs(toParseNum(resMaps.S.substring(0, 3)));
+          }
+          if (resMaps.Z) {
+            return parseTimeZone(resMaps);
+          } else {
+            return new Date(resMaps.y, resMaps.M || 0, resMaps.d || 1, resMaps.H || 0, resMaps.m || 0, resMaps.s || 0, resMaps.S || 0);
+          }
+        }
+      }
+    }
+    return /* @__PURE__ */ new Date("");
+  }
+  toStringDate_1 = toStringDate;
+  return toStringDate_1;
+}
+export {
+  requireToStringDate as __require
+};

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

@@ -0,0 +1,26 @@
+import { __require as requireIsPlainObject } from "./isPlainObject.mjs";
+import { __require as requireIsString } from "./isString.mjs";
+var toStringJSON_1;
+var hasRequiredToStringJSON;
+function requireToStringJSON() {
+  if (hasRequiredToStringJSON) return toStringJSON_1;
+  hasRequiredToStringJSON = 1;
+  var isPlainObject = requireIsPlainObject();
+  var isString = requireIsString();
+  function toStringJSON(str) {
+    if (isPlainObject(str)) {
+      return str;
+    } else if (isString(str)) {
+      try {
+        return JSON.parse(str);
+      } catch (e) {
+      }
+    }
+    return {};
+  }
+  toStringJSON_1 = toStringJSON;
+  return toStringJSON_1;
+}
+export {
+  requireToStringJSON as __require
+};

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

@@ -0,0 +1,45 @@
+import { __require as requireSetupDefaults } from "./setupDefaults.mjs";
+import { __require as requireArrayEach } from "./arrayEach.mjs";
+import { __require as requireAssign } from "./assign.mjs";
+var toTreeArray_1;
+var hasRequiredToTreeArray;
+function requireToTreeArray() {
+  if (hasRequiredToTreeArray) return toTreeArray_1;
+  hasRequiredToTreeArray = 1;
+  var setupDefaults = requireSetupDefaults();
+  var arrayEach = requireArrayEach();
+  var assign = requireAssign();
+  function unTreeList(result, parentItem, array, opts) {
+    var optKey = opts.key;
+    var optParentKey = opts.parentKey;
+    var optChildren = opts.children;
+    var optData = opts.data;
+    var optUpdated = opts.updated;
+    var optClear = opts.clear;
+    arrayEach(array, function(item) {
+      var childList = item[optChildren];
+      if (optData) {
+        item = item[optData];
+      }
+      if (optUpdated !== false) {
+        item[optParentKey] = parentItem ? parentItem[optKey] : null;
+      }
+      result.push(item);
+      if (childList && childList.length) {
+        unTreeList(result, item, childList, opts);
+      }
+      if (optClear) {
+        delete item[optChildren];
+      }
+    });
+    return result;
+  }
+  function toTreeArray(array, options) {
+    return unTreeList([], null, array, assign({}, setupDefaults.treeOptions, options));
+  }
+  toTreeArray_1 = toTreeArray;
+  return toTreeArray_1;
+}
+export {
+  requireToTreeArray as __require
+};

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

@@ -0,0 +1,23 @@
+import { __require as requireEqNull } from "./eqNull.mjs";
+import { __require as requireIsNumber } from "./isNumber.mjs";
+import { __require as requireToNumberString } from "./toNumberString.mjs";
+var toValueString_1;
+var hasRequiredToValueString;
+function requireToValueString() {
+  if (hasRequiredToValueString) return toValueString_1;
+  hasRequiredToValueString = 1;
+  var eqNull = requireEqNull();
+  var isNumber = requireIsNumber();
+  var toNumberString = requireToNumberString();
+  function toValueString(obj) {
+    if (isNumber(obj)) {
+      return toNumberString(obj);
+    }
+    return "" + (eqNull(obj) ? "" : obj);
+  }
+  toValueString_1 = toValueString;
+  return toValueString_1;
+}
+export {
+  requireToValueString as __require
+};

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

@@ -0,0 +1,18 @@
+import { __require as requireTrimRight } from "./trimRight.mjs";
+import { __require as requireTrimLeft } from "./trimLeft.mjs";
+var trim_1;
+var hasRequiredTrim;
+function requireTrim() {
+  if (hasRequiredTrim) return trim_1;
+  hasRequiredTrim = 1;
+  var trimRight = requireTrimRight();
+  var trimLeft = requireTrimLeft();
+  function trim(str) {
+    return str && str.trim ? str.trim() : trimRight(trimLeft(str));
+  }
+  trim_1 = trim;
+  return trim_1;
+}
+export {
+  requireTrim as __require
+};

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

@@ -0,0 +1,16 @@
+import { __require as requireToValueString } from "./toValueString.mjs";
+var trimLeft_1;
+var hasRequiredTrimLeft;
+function requireTrimLeft() {
+  if (hasRequiredTrimLeft) return trimLeft_1;
+  hasRequiredTrimLeft = 1;
+  var toValueString = requireToValueString();
+  function trimLeft(str) {
+    return str && str.trimLeft ? str.trimLeft() : toValueString(str).replace(/^[\s\uFEFF\xA0]+/g, "");
+  }
+  trimLeft_1 = trimLeft;
+  return trimLeft_1;
+}
+export {
+  requireTrimLeft as __require
+};

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

@@ -0,0 +1,16 @@
+import { __require as requireToValueString } from "./toValueString.mjs";
+var trimRight_1;
+var hasRequiredTrimRight;
+function requireTrimRight() {
+  if (hasRequiredTrimRight) return trimRight_1;
+  hasRequiredTrimRight = 1;
+  var toValueString = requireToValueString();
+  function trimRight(str) {
+    return str && str.trimRight ? str.trimRight() : toValueString(str).replace(/[\s\uFEFF\xA0]+$/g, "");
+  }
+  trimRight_1 = trimRight;
+  return trimRight_1;
+}
+export {
+  requireTrimRight as __require
+};

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

@@ -0,0 +1,22 @@
+import { __require as requireStaticEscapeMap } from "./staticEscapeMap.mjs";
+import { __require as requireHelperFormatEscaper } from "./helperFormatEscaper.mjs";
+import { __require as requireEach } from "./each.mjs";
+var _unescape;
+var hasRequired_unescape;
+function require_unescape() {
+  if (hasRequired_unescape) return _unescape;
+  hasRequired_unescape = 1;
+  var staticEscapeMap = requireStaticEscapeMap();
+  var helperFormatEscaper = requireHelperFormatEscaper();
+  var each = requireEach();
+  var unescapeMap = {};
+  each(staticEscapeMap, function(item, key) {
+    unescapeMap[staticEscapeMap[key]] = key;
+  });
+  var unescape = helperFormatEscaper(unescapeMap);
+  _unescape = unescape;
+  return _unescape;
+}
+export {
+  require_unescape as __require
+};

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

@@ -0,0 +1,25 @@
+import { __require as requireUniq } from "./uniq.mjs";
+import { __require as requireToArray } from "./toArray.mjs";
+var union_1;
+var hasRequiredUnion;
+function requireUnion() {
+  if (hasRequiredUnion) return union_1;
+  hasRequiredUnion = 1;
+  var uniq = requireUniq();
+  var toArray = requireToArray();
+  function union() {
+    var args = arguments;
+    var result = [];
+    var index = 0;
+    var len = args.length;
+    for (; index < len; index++) {
+      result = result.concat(toArray(args[index]));
+    }
+    return uniq(result);
+  }
+  union_1 = union;
+  return union_1;
+}
+export {
+  requireUnion as __require
+};

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

@@ -0,0 +1,42 @@
+import { __require as requireEach } from "./each.mjs";
+import { __require as requireIncludes } from "./includes.mjs";
+import { __require as requireIsFunction } from "./isFunction.mjs";
+import { __require as requireProperty } from "./property.mjs";
+var uniq_1;
+var hasRequiredUniq;
+function requireUniq() {
+  if (hasRequiredUniq) return uniq_1;
+  hasRequiredUniq = 1;
+  var each = requireEach();
+  var includes = requireIncludes();
+  var isFunction = requireIsFunction();
+  var property = requireProperty();
+  function uniq(array, iterate, context) {
+    var result = [];
+    if (iterate) {
+      if (!isFunction(iterate)) {
+        iterate = property(iterate);
+      }
+      var val, valMap = {};
+      each(array, function(item, key) {
+        val = iterate.call(context, item, key, array);
+        if (!valMap[val]) {
+          valMap[val] = 1;
+          result.push(item);
+        }
+      });
+    } else {
+      each(array, function(value) {
+        if (!includes(result, value)) {
+          result.push(value);
+        }
+      });
+    }
+    return result;
+  }
+  uniq_1 = uniq;
+  return uniq_1;
+}
+export {
+  requireUniq as __require
+};

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

@@ -0,0 +1,18 @@
+import { __require as requireSetupDefaults } from "./setupDefaults.mjs";
+import { __require as requireEqNull } from "./eqNull.mjs";
+var uniqueId_1;
+var hasRequiredUniqueId;
+function requireUniqueId() {
+  if (hasRequiredUniqueId) return uniqueId_1;
+  hasRequiredUniqueId = 1;
+  var setupDefaults = requireSetupDefaults();
+  var eqNull = requireEqNull();
+  function uniqueId(prefix) {
+    return "" + (eqNull(prefix) ? "" : prefix) + setupDefaults.keyId++;
+  }
+  uniqueId_1 = uniqueId;
+  return uniqueId_1;
+}
+export {
+  requireUniqueId as __require
+};

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

@@ -0,0 +1,28 @@
+import { __require as requireStaticDecodeURIComponent } from "./staticDecodeURIComponent.mjs";
+import { __require as requireArrayEach } from "./arrayEach.mjs";
+import { __require as requireIsString } from "./isString.mjs";
+var unserialize_1;
+var hasRequiredUnserialize;
+function requireUnserialize() {
+  if (hasRequiredUnserialize) return unserialize_1;
+  hasRequiredUnserialize = 1;
+  var staticDecodeURIComponent = requireStaticDecodeURIComponent();
+  var arrayEach = requireArrayEach();
+  var isString = requireIsString();
+  function unserialize(str) {
+    var items;
+    var result = {};
+    if (str && isString(str)) {
+      arrayEach(str.split("&"), function(param) {
+        items = param.split("=");
+        result[staticDecodeURIComponent(items[0])] = staticDecodeURIComponent(items[1] || "");
+      });
+    }
+    return result;
+  }
+  unserialize_1 = unserialize;
+  return unserialize_1;
+}
+export {
+  requireUnserialize as __require
+};

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

@@ -0,0 +1,29 @@
+import { __require as requirePluck } from "./pluck.mjs";
+import { __require as requireMax } from "./max.mjs";
+var unzip_1;
+var hasRequiredUnzip;
+function requireUnzip() {
+  if (hasRequiredUnzip) return unzip_1;
+  hasRequiredUnzip = 1;
+  var pluck = requirePluck();
+  var max = requireMax();
+  function unzip(arrays) {
+    var index, maxItem, len;
+    var result = [];
+    if (arrays && arrays.length) {
+      index = 0;
+      maxItem = max(arrays, function(item) {
+        return item ? item.length : 0;
+      });
+      for (len = maxItem ? maxItem.length : 0; index < len; index++) {
+        result.push(pluck(arrays, index));
+      }
+    }
+    return result;
+  }
+  unzip_1 = unzip;
+  return unzip_1;
+}
+export {
+  requireUnzip as __require
+};

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

@@ -0,0 +1,14 @@
+import { __require as requireHelperCreateGetObjects } from "./helperCreateGetObjects.mjs";
+var values_1;
+var hasRequiredValues;
+function requireValues() {
+  if (hasRequiredValues) return values_1;
+  hasRequiredValues = 1;
+  var helperCreateGetObjects = requireHelperCreateGetObjects();
+  var values = helperCreateGetObjects("values", 0);
+  values_1 = values;
+  return values_1;
+}
+export {
+  requireValues as __require
+};

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

@@ -0,0 +1,16 @@
+import { __require as requireUnzip } from "./unzip.mjs";
+var zip_1;
+var hasRequiredZip;
+function requireZip() {
+  if (hasRequiredZip) return zip_1;
+  hasRequiredZip = 1;
+  var unzip = requireUnzip();
+  function zip() {
+    return unzip(arguments);
+  }
+  zip_1 = zip;
+  return zip_1;
+}
+export {
+  requireZip as __require
+};

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

@@ -0,0 +1,23 @@
+import { __require as requireValues } from "./values.mjs";
+import { __require as requireEach } from "./each.mjs";
+var zipObject_1;
+var hasRequiredZipObject;
+function requireZipObject() {
+  if (hasRequiredZipObject) return zipObject_1;
+  hasRequiredZipObject = 1;
+  var values = requireValues();
+  var each = requireEach();
+  function zipObject(props, arr) {
+    var result = {};
+    arr = arr || [];
+    each(values(props), function(val, key) {
+      result[val] = arr[key];
+    });
+    return result;
+  }
+  zipObject_1 = zipObject;
+  return zipObject_1;
+}
+export {
+  requireZipObject as __require
+};

package/es/packages/mobile/src/components/dataDisplay/table/Table.vue.mjs

@@ -3,7 +3,7 @@
 /* empty css                                                                                                                    */
 /* empty css                                                                                                                 */
 import { computed, ref, onMounted, createVNode, render, watch, nextTick, createBlock, openBlock, normalizeStyle, normalizeClass, unref, withCtx, isRef, createSlots, createElementBlock, createCommentVNode, Fragment, createElementVNode, renderList, renderSlot } from "vue";
-import "../../../../../../node_modules/.pnpm/vxe-table@4.13.2_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/components.mjs";
+import "../../../../../../node_modules/.pnpm/vxe-table@4.17.0_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/components.mjs";
 import { useDataSource } from "../../../utils/dataSourceUtil.mjs";
 /* empty css                                                                                                                       */
 import { textFormatter, dateFormatter, cascadeFormatter, multipleFormatter, selectFormatter } from "../../../utils/formatterUtil.mjs";
@@ -17,7 +17,7 @@ import { textFormatter, dateFormatter, cascadeFormatter, multipleFormatter, sele
 /* empty css                                                                                                                   */
 /* empty css            */
 import _export_sfc from "../../../../../../_virtual/_plugin-vue_export-helper.mjs";
-import { VxeGrid } from "../../../../../../node_modules/.pnpm/vxe-table@4.13.2_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/grid/index.mjs";
+import { VxeGrid } from "../../../../../../node_modules/.pnpm/vxe-table@4.17.0_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/grid/index.mjs";
 import { SwipeCell } from "../../../../../../node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/swipe-cell/index.mjs";
 import { Button } from "../../../../../../node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/button/index.mjs";
 import { showConfirmDialog } from "../../../../../../node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/dialog/function-call.mjs";
@@ -473,22 +473,7 @@ const _sfc_main = {
                 showHeader: __props.showHeader,
                 onScrollBoundary: onScrollLoads,
                 virtualYConfig,
-                onCellClick: cellClickEvent,
-                fit: false,
-                resizable: false,
-                highlightCurrentRow: false,
-                highlightHoverRow: false,
-                highlightCurrentColumn: false,
-                highlightHoverColumn: false,
-                showOverflow: true,
-                showHeaderOverflow: true,
-                showFooterOverflow: true,
-                rowId: "",
-                emptyText: "没有更多数据了！",
-                keepSource: false,
-                autoResize: true,
-                animat: false,
-                delayHover: false
+                onCellClick: cellClickEvent
               }, createSlots({
                 loading: withCtx(() => [
                   _cache[2] || (_cache[2] = createElementVNode("div", {
@@ -564,7 +549,7 @@ const _sfc_main = {
     };
   }
 };
-const _Table = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-77f88bc5"]]);
+const _Table = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-cb4cdc86"]]);
 export {
   _Table as default
 };

package/lib/_virtual/index2.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const _commonjsHelpers = require("./_commonjsHelpers.js");
+const index = require("../node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/index.js");
+var xeUtilsExports = index.__require();
+const XEUtils = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(xeUtilsExports);
+exports.default = XEUtils;