@fecp/designer 5.5.48 → 5.5.49

package/lib/node_modules/min-dash/dist/index.esm.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const nativeToString = Object.prototype.toString;
+const nativeHasOwnProperty = Object.prototype.hasOwnProperty;
+function isUndefined(obj) {
+  return obj === void 0;
+}
+function isDefined(obj) {
+  return obj !== void 0;
+}
+function isNil(obj) {
+  return obj == null;
+}
+function isArray(obj) {
+  return nativeToString.call(obj) === "[object Array]";
+}
+function isObject(obj) {
+  return nativeToString.call(obj) === "[object Object]";
+}
+function isNumber(obj) {
+  return nativeToString.call(obj) === "[object Number]";
+}
+function isFunction(obj) {
+  const tag = nativeToString.call(obj);
+  return tag === "[object Function]" || tag === "[object AsyncFunction]" || tag === "[object GeneratorFunction]" || tag === "[object AsyncGeneratorFunction]" || tag === "[object Proxy]";
+}
+function isString(obj) {
+  return nativeToString.call(obj) === "[object String]";
+}
+function has(target, key) {
+  return !isNil(target) && nativeHasOwnProperty.call(target, key);
+}
+function find(collection, matcher) {
+  const matchFn = toMatcher(matcher);
+  let match;
+  forEach(collection, function(val, key) {
+    if (matchFn(val, key)) {
+      match = val;
+      return false;
+    }
+  });
+  return match;
+}
+function findIndex(collection, matcher) {
+  const matchFn = toMatcher(matcher);
+  let idx = isArray(collection) ? -1 : void 0;
+  forEach(collection, function(val, key) {
+    if (matchFn(val, key)) {
+      idx = key;
+      return false;
+    }
+  });
+  return idx;
+}
+function filter(collection, matcher) {
+  const matchFn = toMatcher(matcher);
+  let result = [];
+  forEach(collection, function(val, key) {
+    if (matchFn(val, key)) {
+      result.push(val);
+    }
+  });
+  return result;
+}
+function forEach(collection, iterator) {
+  let val, result;
+  if (isUndefined(collection)) {
+    return;
+  }
+  const convertKey = isArray(collection) ? toNum : identity;
+  for (let key in collection) {
+    if (has(collection, key)) {
+      val = collection[key];
+      result = iterator(val, convertKey(key));
+      if (result === false) {
+        return val;
+      }
+    }
+  }
+}
+function reduce(collection, iterator, result) {
+  forEach(collection, function(value, idx) {
+    result = iterator(result, value, idx);
+  });
+  return result;
+}
+function every(collection, matcher) {
+  return !!reduce(collection, function(matches, val, key) {
+    return matches && matcher(val, key);
+  }, true);
+}
+function some(collection, matcher) {
+  return !!find(collection, matcher);
+}
+function map(collection, fn) {
+  let result = [];
+  forEach(collection, function(val, key) {
+    result.push(fn(val, key));
+  });
+  return result;
+}
+function matchPattern(pattern) {
+  return function(el) {
+    return every(pattern, function(val, key) {
+      return el[key] === val;
+    });
+  };
+}
+function toMatcher(matcher) {
+  return isFunction(matcher) ? matcher : (e) => {
+    return e === matcher;
+  };
+}
+function identity(arg) {
+  return arg;
+}
+function toNum(arg) {
+  return Number(arg);
+}
+function debounce(fn, timeout) {
+  let timer;
+  let lastArgs;
+  let lastThis;
+  let lastNow;
+  function fire(force) {
+    let now = Date.now();
+    let scheduledDiff = force ? 0 : lastNow + timeout - now;
+    if (scheduledDiff > 0) {
+      return schedule(scheduledDiff);
+    }
+    fn.apply(lastThis, lastArgs);
+    clear();
+  }
+  function schedule(timeout2) {
+    timer = setTimeout(fire, timeout2);
+  }
+  function clear() {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = lastNow = lastArgs = lastThis = void 0;
+  }
+  function flush() {
+    if (timer) {
+      fire(true);
+    }
+    clear();
+  }
+  function callback(...args) {
+    lastNow = Date.now();
+    lastArgs = args;
+    lastThis = this;
+    if (!timer) {
+      schedule(timeout);
+    }
+  }
+  callback.flush = flush;
+  callback.cancel = clear;
+  return callback;
+}
+function bind(fn, target) {
+  return fn.bind(target);
+}
+function assign(target, ...others) {
+  return Object.assign(target, ...others);
+}
+function set(target, path, value) {
+  let currentTarget = target;
+  forEach(path, function(key, idx) {
+    if (typeof key !== "number" && typeof key !== "string") {
+      throw new Error("illegal key type: " + typeof key + ". Key should be of type number or string.");
+    }
+    if (key === "constructor") {
+      throw new Error("illegal key: constructor");
+    }
+    if (key === "__proto__") {
+      throw new Error("illegal key: __proto__");
+    }
+    let nextKey = path[idx + 1];
+    let nextTarget = currentTarget[key];
+    if (isDefined(nextKey) && isNil(nextTarget)) {
+      nextTarget = currentTarget[key] = isNaN(+nextKey) ? {} : [];
+    }
+    if (isUndefined(nextKey)) {
+      if (isUndefined(value)) {
+        delete currentTarget[key];
+      } else {
+        currentTarget[key] = value;
+      }
+    } else {
+      currentTarget = nextTarget;
+    }
+  });
+  return target;
+}
+function pick(target, properties) {
+  let result = {};
+  let obj = Object(target);
+  forEach(properties, function(prop) {
+    if (prop in obj) {
+      result[prop] = target[prop];
+    }
+  });
+  return result;
+}
+function omit(target, properties) {
+  let result = {};
+  let obj = Object(target);
+  forEach(obj, function(prop, key) {
+    if (properties.indexOf(key) === -1) {
+      result[key] = prop;
+    }
+  });
+  return result;
+}
+exports.assign = assign;
+exports.bind = bind;
+exports.debounce = debounce;
+exports.every = every;
+exports.filter = filter;
+exports.find = find;
+exports.findIndex = findIndex;
+exports.forEach = forEach;
+exports.has = has;
+exports.isArray = isArray;
+exports.isDefined = isDefined;
+exports.isFunction = isFunction;
+exports.isNil = isNil;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isString = isString;
+exports.isUndefined = isUndefined;
+exports.map = map;
+exports.matchPattern = matchPattern;
+exports.omit = omit;
+exports.pick = pick;
+exports.reduce = reduce;
+exports.set = set;
+exports.some = some;

package/lib/node_modules/min-dom/dist/index.esm.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function _mergeNamespaces$1(n, m) {
+  m.forEach(function(e) {
+    e && typeof e !== "string" && !Array.isArray(e) && Object.keys(e).forEach(function(k) {
+      if (k !== "default" && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function() {
+            return e[k];
+          }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+const nativeToString = Object.prototype.toString;
+const nativeHasOwnProperty = Object.prototype.hasOwnProperty;
+function isUndefined(obj) {
+  return obj === void 0;
+}
+function isArray(obj) {
+  return nativeToString.call(obj) === "[object Array]";
+}
+function has(target, key) {
+  return nativeHasOwnProperty.call(target, key);
+}
+function forEach(collection, iterator) {
+  let val, result;
+  if (isUndefined(collection)) {
+    return;
+  }
+  const convertKey = isArray(collection) ? toNum : identity;
+  for (let key in collection) {
+    if (has(collection, key)) {
+      val = collection[key];
+      result = iterator(val, convertKey(key));
+      if (result === false) {
+        return val;
+      }
+    }
+  }
+}
+function identity(arg) {
+  return arg;
+}
+function toNum(arg) {
+  return Number(arg);
+}
+function assign(element, ...styleSources) {
+  const target = element.style;
+  forEach(styleSources, function(style) {
+    if (!style) {
+      return;
+    }
+    forEach(style, function(value, key) {
+      target[key] = value;
+    });
+  });
+  return element;
+}
+function attr(el, name, val) {
+  if (arguments.length == 2) {
+    return el.getAttribute(name);
+  }
+  if (val === null) {
+    return el.removeAttribute(name);
+  }
+  el.setAttribute(name, val);
+  return el;
+}
+const toString = Object.prototype.toString;
+function classes(el) {
+  return new ClassList(el);
+}
+function ClassList(el) {
+  if (!el || !el.nodeType) {
+    throw new Error("A DOM element reference is required");
+  }
+  this.el = el;
+  this.list = el.classList;
+}
+ClassList.prototype.add = function(name) {
+  this.list.add(name);
+  return this;
+};
+ClassList.prototype.remove = function(name) {
+  if ("[object RegExp]" == toString.call(name)) {
+    return this.removeMatching(name);
+  }
+  this.list.remove(name);
+  return this;
+};
+ClassList.prototype.removeMatching = function(re) {
+  const arr = this.array();
+  for (let i = 0; i < arr.length; i++) {
+    if (re.test(arr[i])) {
+      this.remove(arr[i]);
+    }
+  }
+  return this;
+};
+ClassList.prototype.toggle = function(name, force) {
+  if ("undefined" !== typeof force) {
+    if (force !== this.list.toggle(name, force)) {
+      this.list.toggle(name);
+    }
+  } else {
+    this.list.toggle(name);
+  }
+  return this;
+};
+ClassList.prototype.array = function() {
+  return Array.from(this.list);
+};
+ClassList.prototype.has = ClassList.prototype.contains = function(name) {
+  return this.list.contains(name);
+};
+function clear(element) {
+  var child;
+  while (child = element.firstChild) {
+    element.removeChild(child);
+  }
+  return element;
+}
+function closest(element, selector, checkYourSelf) {
+  var actualElement = checkYourSelf ? element : element.parentNode;
+  return actualElement && typeof actualElement.closest === "function" && actualElement.closest(selector) || null;
+}
+var componentEvent = {};
+var bind$1, unbind$1, prefix;
+function detect() {
+  bind$1 = window.addEventListener ? "addEventListener" : "attachEvent";
+  unbind$1 = window.removeEventListener ? "removeEventListener" : "detachEvent";
+  prefix = bind$1 !== "addEventListener" ? "on" : "";
+}
+var bind_1 = componentEvent.bind = function(el, type, fn, capture) {
+  if (!bind$1) detect();
+  el[bind$1](prefix + type, fn, capture || false);
+  return fn;
+};
+var unbind_1 = componentEvent.unbind = function(el, type, fn, capture) {
+  if (!unbind$1) detect();
+  el[unbind$1](prefix + type, fn, capture || false);
+  return fn;
+};
+var event = /* @__PURE__ */ _mergeNamespaces$1({
+  __proto__: null,
+  bind: bind_1,
+  unbind: unbind_1,
+  "default": componentEvent
+}, [componentEvent]);
+var forceCaptureEvents = ["focus", "blur"];
+function bind(el, selector, type, fn, capture) {
+  if (forceCaptureEvents.indexOf(type) !== -1) {
+    capture = true;
+  }
+  return event.bind(el, type, function(e) {
+    var target = e.target || e.srcElement;
+    e.delegateTarget = closest(target, selector, true);
+    if (e.delegateTarget) {
+      fn.call(el, e);
+    }
+  }, capture);
+}
+function unbind(el, type, fn, capture) {
+  if (forceCaptureEvents.indexOf(type) !== -1) {
+    capture = true;
+  }
+  return event.unbind(el, type, fn, capture);
+}
+var delegate = {
+  bind,
+  unbind
+};
+var domify = parse;
+var innerHTMLBug = false;
+var bugTestDiv;
+if (typeof document !== "undefined") {
+  bugTestDiv = document.createElement("div");
+  bugTestDiv.innerHTML = '  <link/><table></table><a href="/a">a</a><input type="checkbox"/>';
+  innerHTMLBug = !bugTestDiv.getElementsByTagName("link").length;
+  bugTestDiv = void 0;
+}
+var map = {
+  legend: [1, "<fieldset>", "</fieldset>"],
+  tr: [2, "<table><tbody>", "</tbody></table>"],
+  col: [2, "<table><tbody></tbody><colgroup>", "</colgroup></table>"],
+  // for script/link/style tags to work in IE6-8, you have to wrap
+  // in a div with a non-whitespace character in front, ha!
+  _default: innerHTMLBug ? [1, "X<div>", "</div>"] : [0, "", ""]
+};
+map.td = map.th = [3, "<table><tbody><tr>", "</tr></tbody></table>"];
+map.option = map.optgroup = [1, '<select multiple="multiple">', "</select>"];
+map.thead = map.tbody = map.colgroup = map.caption = map.tfoot = [1, "<table>", "</table>"];
+map.polyline = map.ellipse = map.polygon = map.circle = map.text = map.line = map.path = map.rect = map.g = [1, '<svg xmlns="http://www.w3.org/2000/svg" version="1.1">', "</svg>"];
+function parse(html, doc) {
+  if ("string" != typeof html) throw new TypeError("String expected");
+  if (!doc) doc = document;
+  var m = /<([\w:]+)/.exec(html);
+  if (!m) return doc.createTextNode(html);
+  html = html.replace(/^\s+|\s+$/g, "");
+  var tag = m[1];
+  if (tag == "body") {
+    var el = doc.createElement("html");
+    el.innerHTML = html;
+    return el.removeChild(el.lastChild);
+  }
+  var wrap = Object.prototype.hasOwnProperty.call(map, tag) ? map[tag] : map._default;
+  var depth = wrap[0];
+  var prefix2 = wrap[1];
+  var suffix = wrap[2];
+  var el = doc.createElement("div");
+  el.innerHTML = prefix2 + html + suffix;
+  while (depth--) el = el.lastChild;
+  if (el.firstChild == el.lastChild) {
+    return el.removeChild(el.firstChild);
+  }
+  var fragment = doc.createDocumentFragment();
+  while (el.firstChild) {
+    fragment.appendChild(el.removeChild(el.firstChild));
+  }
+  return fragment;
+}
+var domify$1 = domify;
+function matches(element, selector) {
+  return element && typeof element.matches === "function" && element.matches(selector) || false;
+}
+function query(selector, el) {
+  el = el || document;
+  return el.querySelector(selector);
+}
+function all(selector, el) {
+  el = el || document;
+  return el.querySelectorAll(selector);
+}
+function remove(el) {
+  el.parentNode && el.parentNode.removeChild(el);
+}
+exports.assignStyle = assign;
+exports.attr = attr;
+exports.classes = classes;
+exports.clear = clear;
+exports.closest = closest;
+exports.delegate = delegate;
+exports.domify = domify$1;
+exports.event = event;
+exports.matches = matches;
+exports.query = query;
+exports.queryAll = all;
+exports.remove = remove;