@fecp/designer 5.4.100 → 5.4.104

package/es/packages/vue/node_modules/xe-utils/debounce.mjs

@@ -0,0 +1,70 @@
+import { __require as requireAssign } from "./assign.mjs";
+var debounce_1;
+var hasRequiredDebounce;
+function requireDebounce() {
+  if (hasRequiredDebounce) return debounce_1;
+  hasRequiredDebounce = 1;
+  var assign = requireAssign();
+  function debounce(callback, wait, options) {
+    var args = null;
+    var context = null;
+    var opts = typeof options === "boolean" ? { leading: options, trailing: !options } : assign({ leading: false, trailing: true }, options);
+    var runFlag = false;
+    var timeout = null;
+    var optLeading = opts.leading;
+    var optTrailing = opts.trailing;
+    var gcFn = function() {
+      args = null;
+      context = null;
+    };
+    var runFn = function() {
+      runFlag = true;
+      callback.apply(context, args);
+      gcFn();
+    };
+    var endFn = function() {
+      if (optLeading === true) {
+        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 debounced = function() {
+      runFlag = false;
+      args = arguments;
+      context = this;
+      if (timeout === null) {
+        if (optLeading === true) {
+          runFn();
+        }
+      } else {
+        clearTimeout(timeout);
+      }
+      timeout = setTimeout(endFn, wait);
+    };
+    debounced.cancel = cancelFn;
+    return debounced;
+  }
+  debounce_1 = debounce;
+  return debounce_1;
+}
+export {
+  requireDebounce as __require
+};

package/es/packages/vue/node_modules/xe-utils/delay.mjs

@@ -0,0 +1,20 @@
+import { __require as requireSlice } from "./slice.mjs";
+var delay_1;
+var hasRequiredDelay;
+function requireDelay() {
+  if (hasRequiredDelay) return delay_1;
+  hasRequiredDelay = 1;
+  var slice = requireSlice();
+  function delay(callback, wait) {
+    var args = slice(arguments, 2);
+    var context = this;
+    return setTimeout(function() {
+      callback.apply(context, args);
+    }, wait);
+  }
+  delay_1 = delay;
+  return delay_1;
+}
+export {
+  requireDelay as __require
+};

package/es/packages/vue/node_modules/xe-utils/destructuring.mjs

@@ -0,0 +1,33 @@
+import { __require as requireKeys } from "./keys.mjs";
+import { __require as requireSlice } from "./slice.mjs";
+import { __require as requireIncludes } from "./includes.mjs";
+import { __require as requireArrayEach } from "./arrayEach.mjs";
+import { __require as requireAssign } from "./assign.mjs";
+var destructuring_1;
+var hasRequiredDestructuring;
+function requireDestructuring() {
+  if (hasRequiredDestructuring) return destructuring_1;
+  hasRequiredDestructuring = 1;
+  var keys = requireKeys();
+  var slice = requireSlice();
+  var includes = requireIncludes();
+  var arrayEach = requireArrayEach();
+  var assign = requireAssign();
+  function destructuring(destination, sources) {
+    if (destination && sources) {
+      var rest = assign.apply(this, [{}].concat(slice(arguments, 1)));
+      var restKeys = keys(rest);
+      arrayEach(keys(destination), function(key) {
+        if (includes(restKeys, key)) {
+          destination[key] = rest[key];
+        }
+      });
+    }
+    return destination;
+  }
+  destructuring_1 = destructuring;
+  return destructuring_1;
+}
+export {
+  requireDestructuring as __require
+};

package/es/packages/vue/node_modules/xe-utils/divide.mjs

@@ -0,0 +1,18 @@
+import { __require as requireHelperNumberDivide } from "./helperNumberDivide.mjs";
+import { __require as requireToNumber } from "./toNumber.mjs";
+var divide_1;
+var hasRequiredDivide;
+function requireDivide() {
+  if (hasRequiredDivide) return divide_1;
+  hasRequiredDivide = 1;
+  var helperNumberDivide = requireHelperNumberDivide();
+  var toNumber = requireToNumber();
+  function divide(num1, num2) {
+    return helperNumberDivide(toNumber(num1), toNumber(num2));
+  }
+  divide_1 = divide;
+  return divide_1;
+}
+export {
+  requireDivide as __require
+};

package/es/packages/vue/node_modules/xe-utils/each.mjs

@@ -0,0 +1,23 @@
+import { __require as requireIsArray } from "./isArray.mjs";
+import { __require as requireArrayEach } from "./arrayEach.mjs";
+import { __require as requireObjectEach } from "./objectEach.mjs";
+var each_1;
+var hasRequiredEach;
+function requireEach() {
+  if (hasRequiredEach) return each_1;
+  hasRequiredEach = 1;
+  var isArray = requireIsArray();
+  var arrayEach = requireArrayEach();
+  var objectEach = requireObjectEach();
+  function each(obj, iterate, context) {
+    if (obj) {
+      return (isArray(obj) ? arrayEach : objectEach)(obj, iterate, context);
+    }
+    return obj;
+  }
+  each_1 = each;
+  return each_1;
+}
+export {
+  requireEach as __require
+};

package/es/packages/vue/node_modules/xe-utils/eachTree.mjs

@@ -0,0 +1,28 @@
+import { __require as requireHelperCreateTreeFunc } from "./helperCreateTreeFunc.mjs";
+import { __require as requireEach } from "./each.mjs";
+var eachTree_1;
+var hasRequiredEachTree;
+function requireEachTree() {
+  if (hasRequiredEachTree) return eachTree_1;
+  hasRequiredEachTree = 1;
+  var helperCreateTreeFunc = requireHelperCreateTreeFunc();
+  var each = requireEach();
+  function eachTreeItem(parent, obj, iterate, context, path, node, parseChildren, opts) {
+    var paths, nodes;
+    each(obj, function(item, index) {
+      paths = path.concat(["" + index]);
+      nodes = node.concat([item]);
+      iterate.call(context, item, index, obj, paths, parent, nodes);
+      if (item && parseChildren) {
+        paths.push(parseChildren);
+        eachTreeItem(item, item[parseChildren], iterate, context, paths, nodes, parseChildren);
+      }
+    });
+  }
+  var eachTree = helperCreateTreeFunc(eachTreeItem);
+  eachTree_1 = eachTree;
+  return eachTree_1;
+}
+export {
+  requireEachTree as __require
+};

package/es/packages/vue/node_modules/xe-utils/endsWith.mjs

@@ -0,0 +1,18 @@
+import { __require as requireToValueString } from "./toValueString.mjs";
+var endsWith_1;
+var hasRequiredEndsWith;
+function requireEndsWith() {
+  if (hasRequiredEndsWith) return endsWith_1;
+  hasRequiredEndsWith = 1;
+  var toValueString = requireToValueString();
+  function endsWith(str, val, startIndex) {
+    var rest = toValueString(str);
+    var argsLen = arguments.length;
+    return argsLen > 1 && (argsLen > 2 ? rest.substring(0, startIndex).indexOf(val) === startIndex - 1 : rest.indexOf(val) === rest.length - 1);
+  }
+  endsWith_1 = endsWith;
+  return endsWith_1;
+}
+export {
+  requireEndsWith as __require
+};

package/es/packages/vue/node_modules/xe-utils/entries.mjs

@@ -0,0 +1,14 @@
+import { __require as requireHelperCreateGetObjects } from "./helperCreateGetObjects.mjs";
+var entries_1;
+var hasRequiredEntries;
+function requireEntries() {
+  if (hasRequiredEntries) return entries_1;
+  hasRequiredEntries = 1;
+  var helperCreateGetObjects = requireHelperCreateGetObjects();
+  var entries = helperCreateGetObjects("entries", 2);
+  entries_1 = entries;
+  return entries_1;
+}
+export {
+  requireEntries as __require
+};

package/es/packages/vue/node_modules/xe-utils/eqNull.mjs

@@ -0,0 +1,18 @@
+import { __require as requireIsNull } from "./isNull.mjs";
+import { __require as requireIsUndefined } from "./isUndefined.mjs";
+var eqNull_1;
+var hasRequiredEqNull;
+function requireEqNull() {
+  if (hasRequiredEqNull) return eqNull_1;
+  hasRequiredEqNull = 1;
+  var isNull = requireIsNull();
+  var isUndefined = requireIsUndefined();
+  function eqNull(obj) {
+    return isNull(obj) || isUndefined(obj);
+  }
+  eqNull_1 = eqNull;
+  return eqNull_1;
+}
+export {
+  requireEqNull as __require
+};

package/es/packages/vue/node_modules/xe-utils/escape.mjs

@@ -0,0 +1,16 @@
+import { __require as requireStaticEscapeMap } from "./staticEscapeMap.mjs";
+import { __require as requireHelperFormatEscaper } from "./helperFormatEscaper.mjs";
+var _escape;
+var hasRequired_escape;
+function require_escape() {
+  if (hasRequired_escape) return _escape;
+  hasRequired_escape = 1;
+  var staticEscapeMap = requireStaticEscapeMap();
+  var helperFormatEscaper = requireHelperFormatEscaper();
+  var escape = helperFormatEscaper(staticEscapeMap);
+  _escape = escape;
+  return _escape;
+}
+export {
+  require_escape as __require
+};

package/es/packages/vue/node_modules/xe-utils/every.mjs

@@ -0,0 +1,14 @@
+import { __require as requireHelperCreateIterateHandle } from "./helperCreateIterateHandle.mjs";
+var every_1;
+var hasRequiredEvery;
+function requireEvery() {
+  if (hasRequiredEvery) return every_1;
+  hasRequiredEvery = 1;
+  var helperCreateIterateHandle = requireHelperCreateIterateHandle();
+  var every = helperCreateIterateHandle("every", 1, 1, false, true);
+  every_1 = every;
+  return every_1;
+}
+export {
+  requireEvery as __require
+};

package/es/packages/vue/node_modules/xe-utils/filter.mjs

@@ -0,0 +1,27 @@
+import { __require as requireEach } from "./each.mjs";
+var filter_1;
+var hasRequiredFilter;
+function requireFilter() {
+  if (hasRequiredFilter) return filter_1;
+  hasRequiredFilter = 1;
+  var each = requireEach();
+  function filter(obj, iterate, context) {
+    var result = [];
+    if (obj && iterate) {
+      if (obj.filter) {
+        return obj.filter(iterate, context);
+      }
+      each(obj, function(val, key) {
+        if (iterate.call(context, val, key, obj)) {
+          result.push(val);
+        }
+      });
+    }
+    return result;
+  }
+  filter_1 = filter;
+  return filter_1;
+}
+export {
+  requireFilter as __require
+};

package/es/packages/vue/node_modules/xe-utils/filterTree.mjs

@@ -0,0 +1,24 @@
+import { __require as requireEachTree } from "./eachTree.mjs";
+var filterTree_1;
+var hasRequiredFilterTree;
+function requireFilterTree() {
+  if (hasRequiredFilterTree) return filterTree_1;
+  hasRequiredFilterTree = 1;
+  var eachTree = requireEachTree();
+  function filterTree(obj, iterate, options, context) {
+    var result = [];
+    if (obj && iterate) {
+      eachTree(obj, function(item, index, items, path, parent, nodes) {
+        if (iterate.call(context, item, index, items, path, parent, nodes)) {
+          result.push(item);
+        }
+      }, options);
+    }
+    return result;
+  }
+  filterTree_1 = filterTree;
+  return filterTree_1;
+}
+export {
+  requireFilterTree as __require
+};

package/es/packages/vue/node_modules/xe-utils/find.mjs

@@ -0,0 +1,14 @@
+import { __require as requireHelperCreateIterateHandle } from "./helperCreateIterateHandle.mjs";
+var find_1;
+var hasRequiredFind;
+function requireFind() {
+  if (hasRequiredFind) return find_1;
+  hasRequiredFind = 1;
+  var helperCreateIterateHandle = requireHelperCreateIterateHandle();
+  var find = helperCreateIterateHandle("find", 1, 3, true);
+  find_1 = find;
+  return find_1;
+}
+export {
+  requireFind as __require
+};

package/es/packages/vue/node_modules/xe-utils/findIndexOf.mjs

@@ -0,0 +1,21 @@
+import { __require as requireHelperCreateiterateIndexOf } from "./helperCreateiterateIndexOf.mjs";
+var findIndexOf_1;
+var hasRequiredFindIndexOf;
+function requireFindIndexOf() {
+  if (hasRequiredFindIndexOf) return findIndexOf_1;
+  hasRequiredFindIndexOf = 1;
+  var helperCreateiterateIndexOf = requireHelperCreateiterateIndexOf();
+  var findIndexOf = helperCreateiterateIndexOf(function(obj, iterate, context) {
+    for (var index = 0, len = obj.length; index < len; index++) {
+      if (iterate.call(context, obj[index], index, obj)) {
+        return index;
+      }
+    }
+    return -1;
+  });
+  findIndexOf_1 = findIndexOf;
+  return findIndexOf_1;
+}
+export {
+  requireFindIndexOf as __require
+};

package/es/packages/vue/node_modules/xe-utils/findKey.mjs

@@ -0,0 +1,14 @@
+import { __require as requireHelperCreateIterateHandle } from "./helperCreateIterateHandle.mjs";
+var findKey_1;
+var hasRequiredFindKey;
+function requireFindKey() {
+  if (hasRequiredFindKey) return findKey_1;
+  hasRequiredFindKey = 1;
+  var helperCreateIterateHandle = requireHelperCreateIterateHandle();
+  var findKey = helperCreateIterateHandle("", 0, 2, true);
+  findKey_1 = findKey;
+  return findKey_1;
+}
+export {
+  requireFindKey as __require
+};

package/es/packages/vue/node_modules/xe-utils/findLast.mjs

@@ -0,0 +1,27 @@
+import { __require as requireIsArray } from "./isArray.mjs";
+import { __require as requireValues } from "./values.mjs";
+var findLast_1;
+var hasRequiredFindLast;
+function requireFindLast() {
+  if (hasRequiredFindLast) return findLast_1;
+  hasRequiredFindLast = 1;
+  var isArray = requireIsArray();
+  var values = requireValues();
+  function findLast(obj, iterate, context) {
+    if (obj) {
+      if (!isArray(obj)) {
+        obj = values(obj);
+      }
+      for (var len = obj.length - 1; len >= 0; len--) {
+        if (iterate.call(context, obj[len], len, obj)) {
+          return obj[len];
+        }
+      }
+    }
+  }
+  findLast_1 = findLast;
+  return findLast_1;
+}
+export {
+  requireFindLast as __require
+};

package/es/packages/vue/node_modules/xe-utils/findLastIndexOf.mjs

@@ -0,0 +1,21 @@
+import { __require as requireHelperCreateiterateIndexOf } from "./helperCreateiterateIndexOf.mjs";
+var findLastIndexOf_1;
+var hasRequiredFindLastIndexOf;
+function requireFindLastIndexOf() {
+  if (hasRequiredFindLastIndexOf) return findLastIndexOf_1;
+  hasRequiredFindLastIndexOf = 1;
+  var helperCreateiterateIndexOf = requireHelperCreateiterateIndexOf();
+  var findLastIndexOf = helperCreateiterateIndexOf(function(obj, iterate, context) {
+    for (var len = obj.length - 1; len >= 0; len--) {
+      if (iterate.call(context, obj[len], len, obj)) {
+        return len;
+      }
+    }
+    return -1;
+  });
+  findLastIndexOf_1 = findLastIndexOf;
+  return findLastIndexOf_1;
+}
+export {
+  requireFindLastIndexOf as __require
+};

package/es/packages/vue/node_modules/xe-utils/findTree.mjs

@@ -0,0 +1,33 @@
+import { __require as requireHelperCreateTreeFunc } from "./helperCreateTreeFunc.mjs";
+var findTree_1;
+var hasRequiredFindTree;
+function requireFindTree() {
+  if (hasRequiredFindTree) return findTree_1;
+  hasRequiredFindTree = 1;
+  var helperCreateTreeFunc = requireHelperCreateTreeFunc();
+  function findTreeItem(parent, obj, iterate, context, path, node, parseChildren, opts) {
+    if (obj) {
+      var item, index, len, paths, nodes, match;
+      for (index = 0, len = obj.length; index < len; index++) {
+        item = obj[index];
+        paths = path.concat(["" + index]);
+        nodes = node.concat([item]);
+        if (iterate.call(context, item, index, obj, paths, parent, nodes)) {
+          return { index, item, path: paths, items: obj, parent, nodes };
+        }
+        if (parseChildren && item) {
+          match = findTreeItem(item, item[parseChildren], iterate, context, paths.concat([parseChildren]), nodes, parseChildren);
+          if (match) {
+            return match;
+          }
+        }
+      }
+    }
+  }
+  var findTree = helperCreateTreeFunc(findTreeItem);
+  findTree_1 = findTree;
+  return findTree_1;
+}
+export {
+  requireFindTree as __require
+};

package/es/packages/vue/node_modules/xe-utils/first.mjs

@@ -0,0 +1,16 @@
+import { __require as requireValues } from "./values.mjs";
+var first_1;
+var hasRequiredFirst;
+function requireFirst() {
+  if (hasRequiredFirst) return first_1;
+  hasRequiredFirst = 1;
+  var values = requireValues();
+  function first(obj) {
+    return values(obj)[0];
+  }
+  first_1 = first;
+  return first_1;
+}
+export {
+  requireFirst as __require
+};

package/es/packages/vue/node_modules/xe-utils/flatten.mjs

@@ -0,0 +1,28 @@
+import { __require as requireIsArray } from "./isArray.mjs";
+import { __require as requireArrayEach } from "./arrayEach.mjs";
+var flatten_1;
+var hasRequiredFlatten;
+function requireFlatten() {
+  if (hasRequiredFlatten) return flatten_1;
+  hasRequiredFlatten = 1;
+  var isArray = requireIsArray();
+  var arrayEach = requireArrayEach();
+  function flattenDeep(array, deep) {
+    var result = [];
+    arrayEach(array, function(vals) {
+      result = result.concat(isArray(vals) ? deep ? flattenDeep(vals, deep) : vals : [vals]);
+    });
+    return result;
+  }
+  function flatten(array, deep) {
+    if (isArray(array)) {
+      return flattenDeep(array, deep);
+    }
+    return [];
+  }
+  flatten_1 = flatten;
+  return flatten_1;
+}
+export {
+  requireFlatten as __require
+};

package/es/packages/vue/node_modules/xe-utils/floor.mjs

@@ -0,0 +1,14 @@
+import { __require as requireHelperCreateMathNumber } from "./helperCreateMathNumber.mjs";
+var floor_1;
+var hasRequiredFloor;
+function requireFloor() {
+  if (hasRequiredFloor) return floor_1;
+  hasRequiredFloor = 1;
+  var helperCreateMathNumber = requireHelperCreateMathNumber();
+  var floor = helperCreateMathNumber("floor");
+  floor_1 = floor;
+  return floor_1;
+}
+export {
+  requireFloor as __require
+};

package/es/packages/vue/node_modules/xe-utils/forOf.mjs

@@ -0,0 +1,34 @@
+import { __require as requireIsArray } from "./isArray.mjs";
+import { __require as requireHasOwnProp } from "./hasOwnProp.mjs";
+var forOf_1;
+var hasRequiredForOf;
+function requireForOf() {
+  if (hasRequiredForOf) return forOf_1;
+  hasRequiredForOf = 1;
+  var isArray = requireIsArray();
+  var hasOwnProp = requireHasOwnProp();
+  function forOf(obj, iterate, context) {
+    if (obj) {
+      if (isArray(obj)) {
+        for (var index = 0, len = obj.length; index < len; index++) {
+          if (iterate.call(context, obj[index], index, obj) === false) {
+            break;
+          }
+        }
+      } else {
+        for (var key in obj) {
+          if (hasOwnProp(obj, key)) {
+            if (iterate.call(context, obj[key], key, obj) === false) {
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  forOf_1 = forOf;
+  return forOf_1;
+}
+export {
+  requireForOf as __require
+};

package/es/packages/vue/node_modules/xe-utils/get.mjs

@@ -0,0 +1,56 @@
+import { __require as requireStaticHGKeyRE } from "./staticHGKeyRE.mjs";
+import { __require as requireHelperGetHGSKeys } from "./helperGetHGSKeys.mjs";
+import { __require as requireHasOwnProp } from "./hasOwnProp.mjs";
+import { __require as requireIsUndefined } from "./isUndefined.mjs";
+import { __require as requireEqNull } from "./eqNull.mjs";
+var get_1;
+var hasRequiredGet;
+function requireGet() {
+  if (hasRequiredGet) return get_1;
+  hasRequiredGet = 1;
+  var staticHGKeyRE = requireStaticHGKeyRE();
+  var helperGetHGSKeys = requireHelperGetHGSKeys();
+  var hasOwnProp = requireHasOwnProp();
+  var isUndefined = requireIsUndefined();
+  var eqNull = requireEqNull();
+  function get(obj, property, defaultValue) {
+    if (eqNull(obj)) {
+      return defaultValue;
+    }
+    var result = getValueByPath(obj, property);
+    return isUndefined(result) ? defaultValue : result;
+  }
+  function getDeepProps(obj, key) {
+    var matchs = key ? key.match(staticHGKeyRE) : "";
+    return matchs ? matchs[1] ? obj[matchs[1]] ? obj[matchs[1]][matchs[2]] : void 0 : obj[matchs[2]] : obj[key];
+  }
+  function getValueByPath(obj, property) {
+    if (obj) {
+      var rest, props, len;
+      var index = 0;
+      if (obj[property] || hasOwnProp(obj, property)) {
+        return obj[property];
+      } else {
+        props = helperGetHGSKeys(property);
+        len = props.length;
+        if (len) {
+          for (rest = obj; index < len; index++) {
+            rest = getDeepProps(rest, props[index]);
+            if (eqNull(rest)) {
+              if (index === len - 1) {
+                return rest;
+              }
+              return;
+            }
+          }
+        }
+        return rest;
+      }
+    }
+  }
+  get_1 = get;
+  return get_1;
+}
+export {
+  requireGet as __require
+};

package/es/packages/vue/node_modules/xe-utils/getBaseURL.mjs

@@ -0,0 +1,25 @@
+import { __require as requireStaticLocation } from "./staticLocation.mjs";
+import { __require as requireHelperGetLocatOrigin } from "./helperGetLocatOrigin.mjs";
+import { __require as requireLastIndexOf } from "./lastIndexOf.mjs";
+var getBaseURL_1;
+var hasRequiredGetBaseURL;
+function requireGetBaseURL() {
+  if (hasRequiredGetBaseURL) return getBaseURL_1;
+  hasRequiredGetBaseURL = 1;
+  var staticLocation = requireStaticLocation();
+  var helperGetLocatOrigin = requireHelperGetLocatOrigin();
+  var lastIndexOf = requireLastIndexOf();
+  function getBaseURL() {
+    if (staticLocation) {
+      var pathname = staticLocation.pathname;
+      var lastIndex = lastIndexOf(pathname, "/") + 1;
+      return helperGetLocatOrigin() + (lastIndex === pathname.length ? pathname : pathname.substring(0, lastIndex));
+    }
+    return "";
+  }
+  getBaseURL_1 = getBaseURL;
+  return getBaseURL_1;
+}
+export {
+  requireGetBaseURL as __require
+};