@fecp/designer 5.4.101 → 5.4.106

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/throttle.mjs

@@ -0,0 +1,59 @@
+import assign from "./assign.mjs";
+function throttle(callback, wait, options) {
+  var args = null;
+  var context = null;
+  var runFlag = false;
+  var timeout = null;
+  var opts = assign({ leading: true, trailing: true }, options);
+  var optLeading = opts.leading;
+  var optTrailing = opts.trailing;
+  var gcFn = function() {
+    args = null;
+    context = null;
+  };
+  var runFn = function() {
+    runFlag = true;
+    callback.apply(context, args);
+    timeout = setTimeout(endFn, wait);
+    gcFn();
+  };
+  var endFn = function() {
+    timeout = null;
+    if (runFlag) {
+      gcFn();
+      return;
+    }
+    if (optTrailing === true) {
+      runFn();
+      return;
+    }
+    gcFn();
+  };
+  var cancelFn = function() {
+    var rest = timeout !== null;
+    if (rest) {
+      clearTimeout(timeout);
+    }
+    gcFn();
+    timeout = null;
+    runFlag = false;
+    return rest;
+  };
+  var throttled = function() {
+    args = arguments;
+    context = this;
+    runFlag = false;
+    if (timeout === null && optLeading === true) {
+      runFn();
+      return;
+    }
+    if (optTrailing === true) {
+      timeout = setTimeout(endFn, wait);
+    }
+  };
+  throttled.cancel = cancelFn;
+  return throttled;
+}
+export {
+  throttle as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/timestamp.mjs

@@ -0,0 +1,14 @@
+import helperGetDateTime from "./helperGetDateTime.mjs";
+import now from "./now.mjs";
+import toStringDate from "./toStringDate.mjs";
+import isDate from "./isDate.mjs";
+var timestamp = function(str, format) {
+  if (str) {
+    var date = toStringDate(str, format);
+    return isDate(date) ? helperGetDateTime(date) : date;
+  }
+  return now();
+};
+export {
+  timestamp as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/toArray.mjs

@@ -0,0 +1,9 @@
+import map from "./map.mjs";
+function toArray(list) {
+  return map(list, function(item) {
+    return item;
+  });
+}
+export {
+  toArray as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/toArrayTree.mjs

@@ -0,0 +1,86 @@
+import setupDefaults from "./setupDefaults.mjs";
+import helperLog from "./helperLog.mjs";
+import orderBy from "./orderBy.mjs";
+import clone from "./clone.mjs";
+import eqNull from "./eqNull.mjs";
+import each from "./each.mjs";
+import remove from "./remove.mjs";
+import assign from "./assign.mjs";
+function strictTree(array, optChildren) {
+  each(array, function(item) {
+    if (item[optChildren] && !item[optChildren].length) {
+      remove(item, optChildren);
+    }
+  });
+}
+function toArrayTree(array, options) {
+  var opts = assign({}, setupDefaults.treeOptions, options);
+  var optStrict = opts.strict;
+  var optKey = opts.key;
+  var optParentKey = opts.parentKey;
+  var optChildren = opts.children;
+  var optMapChildren = opts.mapChildren;
+  var optSortKey = opts.sortKey;
+  var optReverse = opts.reverse;
+  var optData = opts.data;
+  var result = [];
+  var defTreeMaps = {};
+  var empTreeMaps = {};
+  var idDefMaps = {};
+  var idEmpMaps = {};
+  var id, treeData, parentId, idMaps, isIdNull, isPdNull, idTreeMaps, pdTreeMaps;
+  if (optSortKey) {
+    array = orderBy(clone(array), optSortKey);
+    if (optReverse) {
+      array = array.reverse();
+    }
+  }
+  each(array, function(item) {
+    id = item[optKey];
+    idMaps = eqNull(id) ? idEmpMaps : idDefMaps;
+    if (idMaps[id]) {
+      helperLog("warn", "Duplicate primary key=" + id);
+    }
+    idMaps[id] = true;
+  });
+  each(array, function(item) {
+    id = item[optKey];
+    isIdNull = eqNull(id);
+    if (optData) {
+      treeData = {};
+      treeData[optData] = item;
+    } else {
+      treeData = item;
+    }
+    parentId = item[optParentKey];
+    isPdNull = eqNull(parentId);
+    idTreeMaps = isIdNull ? empTreeMaps : defTreeMaps;
+    idTreeMaps[id] = idTreeMaps[id] || [];
+    treeData[optKey] = id;
+    treeData[optParentKey] = parentId;
+    if (id === parentId) {
+      parentId = null;
+      helperLog("warn", "Error infinite Loop. key=" + id + " parentKey=" + id);
+    }
+    pdTreeMaps = isPdNull ? empTreeMaps : defTreeMaps;
+    idMaps = isPdNull ? idEmpMaps : idDefMaps;
+    pdTreeMaps[parentId] = pdTreeMaps[parentId] || [];
+    pdTreeMaps[parentId].push(treeData);
+    treeData[optChildren] = idTreeMaps[id];
+    if (optMapChildren) {
+      treeData[optMapChildren] = idTreeMaps[id];
+    }
+    if (!optStrict || optStrict && isPdNull) {
+      if (!idMaps[parentId]) {
+        result.push(treeData);
+      }
+    }
+  });
+  if (optStrict) {
+    strictTree(array, optChildren);
+  }
+  return result;
+}
+export {
+  toArrayTree as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/toDateString.mjs

@@ -0,0 +1,117 @@
+import setupDefaults from "./setupDefaults.mjs";
+import helperStringUpperCase from "./helperStringUpperCase.mjs";
+import helperGetDateFullYear from "./helperGetDateFullYear.mjs";
+import helperGetDateMonth from "./helperGetDateMonth.mjs";
+import toStringDate from "./toStringDate.mjs";
+import getYearWeek from "./getYearWeek.mjs";
+import getYearDay from "./getYearDay.mjs";
+import assign from "./assign.mjs";
+import isValidDate from "./isValidDate.mjs";
+import isFunction from "./isFunction.mjs";
+import eqNull from "./eqNull.mjs";
+import padStart from "./padStart.mjs";
+function handleCustomTemplate(date, formats, match, value) {
+  var format = formats[match];
+  if (format) {
+    if (isFunction(format)) {
+      return format(value, match, date);
+    } else {
+      return format[value];
+    }
+  }
+  return value;
+}
+var dateFormatRE = /\[([^\]]+)]|y{2,4}|M{1,2}|d{1,2}|H{1,2}|h{1,2}|m{1,2}|s{1,2}|S{1,3}|Z{1,2}|W{1,2}|D{1,3}|[aAeEq]/g;
+function toDateString(date, format, options) {
+  if (date) {
+    date = toStringDate(date);
+    if (isValidDate(date)) {
+      var opts = options || {};
+      var result = format || setupDefaults.parseDateFormat || setupDefaults.formatString;
+      var hours = date.getHours();
+      var apm = hours < 12 ? "am" : "pm";
+      var formats = assign({}, setupDefaults.parseDateRules || setupDefaults.formatStringMatchs, opts.formats);
+      var fy = function(match, length) {
+        return ("" + helperGetDateFullYear(date)).substring(4 - length);
+      };
+      var fM = function(match, length) {
+        return padStart(helperGetDateMonth(date) + 1, length, "0");
+      };
+      var fd = function(match, length) {
+        return padStart(date.getDate(), length, "0");
+      };
+      var fH = function(match, length) {
+        return padStart(hours, length, "0");
+      };
+      var fh = function(match, length) {
+        return padStart(hours <= 12 ? hours : hours - 12, length, "0");
+      };
+      var fm = function(match, length) {
+        return padStart(date.getMinutes(), length, "0");
+      };
+      var fs = function(match, length) {
+        return padStart(date.getSeconds(), length, "0");
+      };
+      var fS = function(match, length) {
+        return padStart(date.getMilliseconds(), length, "0");
+      };
+      var fZ = function(match, length) {
+        var zoneHours = date.getTimezoneOffset() / 60 * -1;
+        return handleCustomTemplate(date, formats, match, (zoneHours >= 0 ? "+" : "-") + padStart(zoneHours, 2, "0") + (length === 1 ? ":" : "") + "00");
+      };
+      var fW = function(match, length) {
+        return padStart(handleCustomTemplate(date, formats, match, getYearWeek(date, eqNull(opts.firstDay) ? setupDefaults.firstDayOfWeek : opts.firstDay)), length, "0");
+      };
+      var fD = function(match, length) {
+        return padStart(handleCustomTemplate(date, formats, match, getYearDay(date)), length, "0");
+      };
+      var parseDates = {
+        yyyy: fy,
+        yy: fy,
+        MM: fM,
+        M: fM,
+        dd: fd,
+        d: fd,
+        HH: fH,
+        H: fH,
+        hh: fh,
+        h: fh,
+        mm: fm,
+        m: fm,
+        ss: fs,
+        s: fs,
+        SSS: fS,
+        S: fS,
+        ZZ: fZ,
+        Z: fZ,
+        WW: fW,
+        W: fW,
+        DDD: fD,
+        D: fD,
+        a: function(match) {
+          return handleCustomTemplate(date, formats, match, apm);
+        },
+        A: function(match) {
+          return handleCustomTemplate(date, formats, match, helperStringUpperCase(apm));
+        },
+        e: function(match) {
+          return handleCustomTemplate(date, formats, match, date.getDay());
+        },
+        E: function(match) {
+          return handleCustomTemplate(date, formats, match, date.getDay());
+        },
+        q: function(match) {
+          return handleCustomTemplate(date, formats, match, Math.floor((helperGetDateMonth(date) + 3) / 3));
+        }
+      };
+      return result.replace(dateFormatRE, function(match, skip) {
+        return skip || (parseDates[match] ? parseDates[match](match, match.length) : match);
+      });
+    }
+    return "Invalid Date";
+  }
+  return "";
+}
+export {
+  toDateString as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/toFixed.mjs

@@ -0,0 +1,22 @@
+import round from "./round.mjs";
+import toValueString from "./toValueString.mjs";
+import helperStringRepeat from "./helperStringRepeat.mjs";
+import helperNumberOffsetPoint from "./helperNumberOffsetPoint.mjs";
+function toFixed(num, digits) {
+  digits = digits >> 0;
+  var str = toValueString(round(num, digits));
+  var nums = str.split(".");
+  var intStr = nums[0];
+  var floatStr = nums[1] || "";
+  var digitOffsetIndex = digits - floatStr.length;
+  if (digits) {
+    if (digitOffsetIndex > 0) {
+      return intStr + "." + floatStr + helperStringRepeat("0", digitOffsetIndex);
+    }
+    return intStr + helperNumberOffsetPoint(floatStr, Math.abs(digitOffsetIndex));
+  }
+  return intStr;
+}
+export {
+  toFixed as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/toFormatString.mjs

@@ -0,0 +1,7 @@
+import template from "./template.mjs";
+function toFormatString(str, obj) {
+  return template(str, obj, { tmplRE: /\{([.\w[\]\s]+)\}/g });
+}
+export {
+  toFormatString as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/toInteger.mjs

@@ -0,0 +1,6 @@
+import staticParseInt from "./staticParseInt.mjs";
+import helperCreateToNumber from "./helperCreateToNumber.mjs";
+var toInteger = helperCreateToNumber(staticParseInt);
+export {
+  toInteger as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/toJSONString.mjs

@@ -0,0 +1,7 @@
+import eqNull from "./eqNull.mjs";
+function toJSONString(obj) {
+  return eqNull(obj) ? "" : JSON.stringify(obj);
+}
+export {
+  toJSONString as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/toNumber.mjs

@@ -0,0 +1,5 @@
+import helperCreateToNumber from "./helperCreateToNumber.mjs";
+var toNumber = helperCreateToNumber(parseFloat);
+export {
+  toNumber as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/toNumberString.mjs

@@ -0,0 +1,41 @@
+import helperStringRepeat from "./helperStringRepeat.mjs";
+import helperNumberOffsetPoint from "./helperNumberOffsetPoint.mjs";
+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;
+}
+export {
+  toNumberString as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/toStringDate.mjs

@@ -0,0 +1,146 @@
+import staticParseInt from "./staticParseInt.mjs";
+import helperGetUTCDateTime from "./helperGetUTCDateTime.mjs";
+import helperGetDateTime from "./helperGetDateTime.mjs";
+import isString from "./isString.mjs";
+import isDate from "./isDate.mjs";
+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 i = 0, dfrLen = defaulParseREs.length; i < dfrLen; i++) {
+    matchRest = str.match(defaulParseREs[i]);
+    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 i = 1, len = matchRest.length; i < len; i++) {
+      resMaps[_i[i - 1]] = matchRest[i];
+    }
+    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("");
+}
+export {
+  toStringDate as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/toStringJSON.mjs

@@ -0,0 +1,16 @@
+import isPlainObject from "./isPlainObject.mjs";
+import isString from "./isString.mjs";
+function toStringJSON(str) {
+  if (isPlainObject(str)) {
+    return str;
+  } else if (isString(str)) {
+    try {
+      return JSON.parse(str);
+    } catch (e) {
+    }
+  }
+  return {};
+}
+export {
+  toStringJSON as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/toTreeArray.mjs

@@ -0,0 +1,34 @@
+import setupDefaults from "./setupDefaults.mjs";
+import arrayEach from "./arrayEach.mjs";
+import assign from "./assign.mjs";
+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));
+}
+export {
+  toTreeArray as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/toValueString.mjs

@@ -0,0 +1,12 @@
+import eqNull from "./eqNull.mjs";
+import isNumber from "./isNumber.mjs";
+import toNumberString from "./toNumberString.mjs";
+function toValueString(obj) {
+  if (isNumber(obj)) {
+    return toNumberString(obj);
+  }
+  return "" + (eqNull(obj) ? "" : obj);
+}
+export {
+  toValueString as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/trim.mjs

@@ -0,0 +1,8 @@
+import trimRight from "./trimRight.mjs";
+import trimLeft from "./trimLeft.mjs";
+function trim(str) {
+  return str && str.trim ? str.trim() : trimRight(trimLeft(str));
+}
+export {
+  trim as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/trimLeft.mjs

@@ -0,0 +1,7 @@
+import toValueString from "./toValueString.mjs";
+function trimLeft(str) {
+  return str && str.trimLeft ? str.trimLeft() : toValueString(str).replace(/^[\s\uFEFF\xA0]+/g, "");
+}
+export {
+  trimLeft as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/trimRight.mjs

@@ -0,0 +1,7 @@
+import toValueString from "./toValueString.mjs";
+function trimRight(str) {
+  return str && str.trimRight ? str.trimRight() : toValueString(str).replace(/[\s\uFEFF\xA0]+$/g, "");
+}
+export {
+  trimRight as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/unescape.mjs

@@ -0,0 +1,11 @@
+import staticEscapeMap from "./staticEscapeMap.mjs";
+import helperFormatEscaper from "./helperFormatEscaper.mjs";
+import each from "./each.mjs";
+var unescapeMap = {};
+each(staticEscapeMap, function(item, key) {
+  unescapeMap[staticEscapeMap[key]] = key;
+});
+var unescape = helperFormatEscaper(unescapeMap);
+export {
+  unescape as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/union.mjs

@@ -0,0 +1,15 @@
+import uniq from "./uniq.mjs";
+import toArray from "./toArray.mjs";
+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);
+}
+export {
+  union as default
+};

package/es/packages/mobile/node_modules/@vxe-ui/core/node_modules/xe-utils/es/uniq.mjs

@@ -0,0 +1,30 @@
+import each from "./each.mjs";
+import includes from "./includes.mjs";
+import isFunction from "./isFunction.mjs";
+import property from "./property.mjs";
+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;
+}
+export {
+  uniq as default
+};