@fecp/designer 5.5.48 → 5.5.50

package/lib/node_modules/diagram-js/lib/util/Text.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index_esm = require("../../../min-dash/dist/index.esm.js");
+const index_esm$1 = require("../../../tiny-svg/dist/index.esm.js");
+const index_esm$2 = require("../../../min-dom/dist/index.esm.js");
+var DEFAULT_BOX_PADDING = 0;
+var DEFAULT_LABEL_SIZE = {
+  width: 150,
+  height: 50
+};
+function parseAlign(align) {
+  var parts = align.split("-");
+  return {
+    horizontal: parts[0] || "center",
+    vertical: parts[1] || "top"
+  };
+}
+function parsePadding(padding) {
+  if (index_esm.isObject(padding)) {
+    return index_esm.assign({ top: 0, left: 0, right: 0, bottom: 0 }, padding);
+  } else {
+    return {
+      top: padding,
+      left: padding,
+      right: padding,
+      bottom: padding
+    };
+  }
+}
+function getTextBBox(text, fakeText) {
+  fakeText.textContent = text;
+  var textBBox;
+  try {
+    var bbox, emptyLine = text === "";
+    fakeText.textContent = emptyLine ? "dummy" : text;
+    textBBox = fakeText.getBBox();
+    bbox = {
+      width: textBBox.width + textBBox.x * 2,
+      height: textBBox.height
+    };
+    if (emptyLine) {
+      bbox.width = 0;
+    }
+    return bbox;
+  } catch (e) {
+    return { width: 0, height: 0 };
+  }
+}
+function layoutNext(lines, maxWidth, fakeText) {
+  var originalLine = lines.shift(), fitLine = originalLine;
+  var textBBox;
+  for (; ; ) {
+    textBBox = getTextBBox(fitLine, fakeText);
+    textBBox.width = fitLine ? textBBox.width : 0;
+    if (fitLine === " " || fitLine === "" || textBBox.width < Math.round(maxWidth) || fitLine.length < 2) {
+      return fit(lines, fitLine, originalLine, textBBox);
+    }
+    fitLine = shortenLine(fitLine, textBBox.width, maxWidth);
+  }
+}
+function fit(lines, fitLine, originalLine, textBBox) {
+  if (fitLine.length < originalLine.length) {
+    var remainder = originalLine.slice(fitLine.length).trim();
+    lines.unshift(remainder);
+  }
+  return {
+    width: textBBox.width,
+    height: textBBox.height,
+    text: fitLine
+  };
+}
+var SOFT_BREAK = "­";
+function semanticShorten(line, maxLength) {
+  var parts = line.split(/(\s|-|\u00AD)/g), part, shortenedParts = [], length = 0;
+  if (parts.length > 1) {
+    while (part = parts.shift()) {
+      if (part.length + length < maxLength) {
+        shortenedParts.push(part);
+        length += part.length;
+      } else {
+        if (part === "-" || part === SOFT_BREAK) {
+          shortenedParts.pop();
+        }
+        break;
+      }
+    }
+  }
+  var last = shortenedParts[shortenedParts.length - 1];
+  if (last && last === SOFT_BREAK) {
+    shortenedParts[shortenedParts.length - 1] = "-";
+  }
+  return shortenedParts.join("");
+}
+function shortenLine(line, width, maxWidth) {
+  var length = Math.max(line.length * (maxWidth / width), 1);
+  var shortenedLine = semanticShorten(line, length);
+  if (!shortenedLine) {
+    shortenedLine = line.slice(0, Math.max(Math.round(length - 1), 1));
+  }
+  return shortenedLine;
+}
+function getHelperSvg() {
+  var helperSvg = document.getElementById("helper-svg");
+  if (!helperSvg) {
+    helperSvg = index_esm$1.create("svg");
+    index_esm$1.attr(helperSvg, {
+      id: "helper-svg"
+    });
+    index_esm$2.assignStyle(helperSvg, {
+      visibility: "hidden",
+      position: "fixed",
+      width: 0,
+      height: 0
+    });
+    document.body.appendChild(helperSvg);
+  }
+  return helperSvg;
+}
+function Text(config) {
+  this._config = index_esm.assign({}, {
+    size: DEFAULT_LABEL_SIZE,
+    padding: DEFAULT_BOX_PADDING,
+    style: {},
+    align: "center-top"
+  }, config || {});
+}
+Text.prototype.createText = function(text, options) {
+  return this.layoutText(text, options).element;
+};
+Text.prototype.getDimensions = function(text, options) {
+  return this.layoutText(text, options).dimensions;
+};
+Text.prototype.layoutText = function(text, options) {
+  var box = index_esm.assign({}, this._config.size, options.box), style = index_esm.assign({}, this._config.style, options.style), align = parseAlign(options.align || this._config.align), padding = parsePadding(options.padding !== void 0 ? options.padding : this._config.padding), fitBox = options.fitBox || false;
+  var lineHeight = getLineHeight(style);
+  var lines = text.split(/\u00AD?\r?\n/), layouted = [];
+  var maxWidth = box.width - padding.left - padding.right;
+  var helperText = index_esm$1.create("text");
+  index_esm$1.attr(helperText, { x: 0, y: 0 });
+  index_esm$1.attr(helperText, style);
+  var helperSvg = getHelperSvg();
+  index_esm$1.append(helperSvg, helperText);
+  while (lines.length) {
+    layouted.push(layoutNext(lines, maxWidth, helperText));
+  }
+  if (align.vertical === "middle") {
+    padding.top = padding.bottom = 0;
+  }
+  var totalHeight = index_esm.reduce(layouted, function(sum, line, idx) {
+    return sum + (lineHeight || line.height);
+  }, 0) + padding.top + padding.bottom;
+  var maxLineWidth = index_esm.reduce(layouted, function(sum, line, idx) {
+    return line.width > sum ? line.width : sum;
+  }, 0);
+  var y = padding.top;
+  if (align.vertical === "middle") {
+    y += (box.height - totalHeight) / 2;
+  }
+  y -= (lineHeight || layouted[0].height) / 4;
+  var textElement = index_esm$1.create("text");
+  index_esm$1.attr(textElement, style);
+  index_esm.forEach(layouted, function(line) {
+    var x;
+    y += lineHeight || line.height;
+    switch (align.horizontal) {
+      case "left":
+        x = padding.left;
+        break;
+      case "right":
+        x = (fitBox ? maxLineWidth : maxWidth) - padding.right - line.width;
+        break;
+      default:
+        x = Math.max(((fitBox ? maxLineWidth : maxWidth) - line.width) / 2 + padding.left, 0);
+    }
+    var tspan = index_esm$1.create("tspan");
+    index_esm$1.attr(tspan, { x, y });
+    tspan.textContent = line.text;
+    index_esm$1.append(textElement, tspan);
+  });
+  index_esm$1.remove(helperText);
+  var dimensions = {
+    width: maxLineWidth,
+    height: totalHeight
+  };
+  return {
+    dimensions,
+    element: textElement
+  };
+};
+function getLineHeight(style) {
+  if ("fontSize" in style && "lineHeight" in style) {
+    return style.lineHeight * parseInt(style.fontSize, 10);
+  }
+}
+exports.default = Text;

package/lib/node_modules/didi/dist/index.esm.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const CLASS_PATTERN = /^class[ {]/;
+function isClass(fn) {
+  return CLASS_PATTERN.test(fn.toString());
+}
+function isArray(obj) {
+  return Array.isArray(obj);
+}
+function hasOwnProp(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+function annotate(...args) {
+  if (args.length === 1 && isArray(args[0])) {
+    args = args[0];
+  }
+  args = [...args];
+  const fn = args.pop();
+  fn.$inject = args;
+  return fn;
+}
+const CONSTRUCTOR_ARGS = /constructor\s*[^(]*\(\s*([^)]*)\)/m;
+const FN_ARGS = /^(?:async\s+)?(?:function\s*[^(]*)?(?:\(\s*([^)]*)\)|(\w+))/m;
+const FN_ARG = /\/\*([^*]*)\*\//m;
+function parseAnnotations(fn) {
+  if (typeof fn !== "function") {
+    throw new Error(`Cannot annotate "${fn}". Expected a function!`);
+  }
+  const match = fn.toString().match(isClass(fn) ? CONSTRUCTOR_ARGS : FN_ARGS);
+  if (!match) {
+    return [];
+  }
+  const args = match[1] || match[2];
+  return args && args.split(",").map((arg) => {
+    const argMatch = arg.match(FN_ARG);
+    return (argMatch && argMatch[1] || arg).trim();
+  }) || [];
+}
+function Injector(modules, parent) {
+  parent = parent || {
+    get: function(name, strict) {
+      currentlyResolving.push(name);
+      if (strict === false) {
+        return null;
+      } else {
+        throw error(`No provider for "${name}"!`);
+      }
+    }
+  };
+  const currentlyResolving = [];
+  const providers = this._providers = Object.create(parent._providers || null);
+  const instances = this._instances = /* @__PURE__ */ Object.create(null);
+  const self = instances.injector = this;
+  const error = function(msg) {
+    const stack = currentlyResolving.join(" -> ");
+    currentlyResolving.length = 0;
+    return new Error(stack ? `${msg} (Resolving: ${stack})` : msg);
+  };
+  function get(name, strict) {
+    if (!providers[name] && name.indexOf(".") !== -1) {
+      const parts = name.split(".");
+      let pivot = get(parts.shift());
+      while (parts.length) {
+        pivot = pivot[parts.shift()];
+      }
+      return pivot;
+    }
+    if (hasOwnProp(instances, name)) {
+      return instances[name];
+    }
+    if (hasOwnProp(providers, name)) {
+      if (currentlyResolving.indexOf(name) !== -1) {
+        currentlyResolving.push(name);
+        throw error("Cannot resolve circular dependency!");
+      }
+      currentlyResolving.push(name);
+      instances[name] = providers[name][0](providers[name][1]);
+      currentlyResolving.pop();
+      return instances[name];
+    }
+    return parent.get(name, strict);
+  }
+  function fnDef(fn, locals) {
+    if (typeof locals === "undefined") {
+      locals = {};
+    }
+    if (typeof fn !== "function") {
+      if (isArray(fn)) {
+        fn = annotate(fn.slice());
+      } else {
+        throw error(`Cannot invoke "${fn}". Expected a function!`);
+      }
+    }
+    const inject = fn.$inject || parseAnnotations(fn);
+    const dependencies = inject.map((dep) => {
+      if (hasOwnProp(locals, dep)) {
+        return locals[dep];
+      } else {
+        return get(dep);
+      }
+    });
+    return {
+      fn,
+      dependencies
+    };
+  }
+  function instantiate(Type) {
+    const {
+      fn,
+      dependencies
+    } = fnDef(Type);
+    const Constructor = Function.prototype.bind.apply(fn, [null].concat(dependencies));
+    return new Constructor();
+  }
+  function invoke(func, context, locals) {
+    const {
+      fn,
+      dependencies
+    } = fnDef(func, locals);
+    return fn.apply(context, dependencies);
+  }
+  function createPrivateInjectorFactory(childInjector) {
+    return annotate((key) => childInjector.get(key));
+  }
+  function createChild(modules2, forceNewInstances) {
+    if (forceNewInstances && forceNewInstances.length) {
+      const fromParentModule = /* @__PURE__ */ Object.create(null);
+      const matchedScopes = /* @__PURE__ */ Object.create(null);
+      const privateInjectorsCache = [];
+      const privateChildInjectors = [];
+      const privateChildFactories = [];
+      let provider;
+      let cacheIdx;
+      let privateChildInjector;
+      let privateChildInjectorFactory;
+      for (let name in providers) {
+        provider = providers[name];
+        if (forceNewInstances.indexOf(name) !== -1) {
+          if (provider[2] === "private") {
+            cacheIdx = privateInjectorsCache.indexOf(provider[3]);
+            if (cacheIdx === -1) {
+              privateChildInjector = provider[3].createChild([], forceNewInstances);
+              privateChildInjectorFactory = createPrivateInjectorFactory(privateChildInjector);
+              privateInjectorsCache.push(provider[3]);
+              privateChildInjectors.push(privateChildInjector);
+              privateChildFactories.push(privateChildInjectorFactory);
+              fromParentModule[name] = [privateChildInjectorFactory, name, "private", privateChildInjector];
+            } else {
+              fromParentModule[name] = [privateChildFactories[cacheIdx], name, "private", privateChildInjectors[cacheIdx]];
+            }
+          } else {
+            fromParentModule[name] = [provider[2], provider[1]];
+          }
+          matchedScopes[name] = true;
+        }
+        if ((provider[2] === "factory" || provider[2] === "type") && provider[1].$scope) {
+          forceNewInstances.forEach((scope) => {
+            if (provider[1].$scope.indexOf(scope) !== -1) {
+              fromParentModule[name] = [provider[2], provider[1]];
+              matchedScopes[scope] = true;
+            }
+          });
+        }
+      }
+      forceNewInstances.forEach((scope) => {
+        if (!matchedScopes[scope]) {
+          throw new Error('No provider for "' + scope + '". Cannot use provider from the parent!');
+        }
+      });
+      modules2.unshift(fromParentModule);
+    }
+    return new Injector(modules2, self);
+  }
+  const factoryMap = {
+    factory: invoke,
+    type: instantiate,
+    value: function(value) {
+      return value;
+    }
+  };
+  function createInitializer(moduleDefinition, injector) {
+    const initializers = moduleDefinition.__init__ || [];
+    return function() {
+      initializers.forEach((initializer) => {
+        if (typeof initializer === "string") {
+          injector.get(initializer);
+        } else {
+          injector.invoke(initializer);
+        }
+      });
+    };
+  }
+  function loadModule(moduleDefinition) {
+    const moduleExports = moduleDefinition.__exports__;
+    if (moduleExports) {
+      const nestedModules = moduleDefinition.__modules__;
+      const clonedModule = Object.keys(moduleDefinition).reduce((clonedModule2, key) => {
+        if (key !== "__exports__" && key !== "__modules__" && key !== "__init__" && key !== "__depends__") {
+          clonedModule2[key] = moduleDefinition[key];
+        }
+        return clonedModule2;
+      }, /* @__PURE__ */ Object.create(null));
+      const childModules = (nestedModules || []).concat(clonedModule);
+      const privateInjector = createChild(childModules);
+      const getFromPrivateInjector = annotate(function(key) {
+        return privateInjector.get(key);
+      });
+      moduleExports.forEach(function(key) {
+        providers[key] = [getFromPrivateInjector, key, "private", privateInjector];
+      });
+      const initializers = (moduleDefinition.__init__ || []).slice();
+      initializers.unshift(function() {
+        privateInjector.init();
+      });
+      moduleDefinition = Object.assign({}, moduleDefinition, {
+        __init__: initializers
+      });
+      return createInitializer(moduleDefinition, privateInjector);
+    }
+    Object.keys(moduleDefinition).forEach(function(key) {
+      if (key === "__init__" || key === "__depends__") {
+        return;
+      }
+      if (moduleDefinition[key][2] === "private") {
+        providers[key] = moduleDefinition[key];
+        return;
+      }
+      const type = moduleDefinition[key][0];
+      const value = moduleDefinition[key][1];
+      providers[key] = [factoryMap[type], arrayUnwrap(type, value), type];
+    });
+    return createInitializer(moduleDefinition, self);
+  }
+  function resolveDependencies(moduleDefinitions, moduleDefinition) {
+    if (moduleDefinitions.indexOf(moduleDefinition) !== -1) {
+      return moduleDefinitions;
+    }
+    moduleDefinitions = (moduleDefinition.__depends__ || []).reduce(resolveDependencies, moduleDefinitions);
+    if (moduleDefinitions.indexOf(moduleDefinition) !== -1) {
+      return moduleDefinitions;
+    }
+    return moduleDefinitions.concat(moduleDefinition);
+  }
+  function bootstrap(moduleDefinitions) {
+    const initializers = moduleDefinitions.reduce(resolveDependencies, []).map(loadModule);
+    let initialized = false;
+    return function() {
+      if (initialized) {
+        return;
+      }
+      initialized = true;
+      initializers.forEach((initializer) => initializer());
+    };
+  }
+  this.get = get;
+  this.invoke = invoke;
+  this.instantiate = instantiate;
+  this.createChild = createChild;
+  this.init = bootstrap(modules);
+}
+function arrayUnwrap(type, value) {
+  if (type !== "value" && isArray(value)) {
+    value = annotate(value.slice());
+  }
+  return value;
+}
+exports.Injector = Injector;
+exports.annotate = annotate;
+exports.parseAnnotations = parseAnnotations;

package/lib/node_modules/ids/dist/index.esm.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function createCommonjsModule(fn, module2) {
+  return module2 = { exports: {} }, fn(module2, module2.exports), module2.exports;
+}
+var hat_1 = createCommonjsModule(function(module2) {
+  var hat = module2.exports = function(bits, base) {
+    if (!base) base = 16;
+    if (bits === void 0) bits = 128;
+    if (bits <= 0) return "0";
+    var digits = Math.log(Math.pow(2, bits)) / Math.log(base);
+    for (var i = 2; digits === Infinity; i *= 2) {
+      digits = Math.log(Math.pow(2, bits / i)) / Math.log(base) * i;
+    }
+    var rem = digits - Math.floor(digits);
+    var res = "";
+    for (var i = 0; i < Math.floor(digits); i++) {
+      var x = Math.floor(Math.random() * base).toString(base);
+      res = x + res;
+    }
+    if (rem) {
+      var b = Math.pow(base, rem);
+      var x = Math.floor(Math.random() * b).toString(base);
+      res = x + res;
+    }
+    var parsed = parseInt(res, base);
+    if (parsed !== Infinity && parsed >= Math.pow(2, bits)) {
+      return hat(bits, base);
+    } else return res;
+  };
+  hat.rack = function(bits, base, expandBy) {
+    var fn = function(data) {
+      var iters = 0;
+      do {
+        if (iters++ > 10) {
+          if (expandBy) bits += expandBy;
+          else throw new Error("too many ID collisions, use more bits");
+        }
+        var id = hat(bits, base);
+      } while (Object.hasOwnProperty.call(hats, id));
+      hats[id] = data;
+      return id;
+    };
+    var hats = fn.hats = {};
+    fn.get = function(id) {
+      return fn.hats[id];
+    };
+    fn.set = function(id, value) {
+      fn.hats[id] = value;
+      return fn;
+    };
+    fn.bits = bits || 128;
+    fn.base = base || 16;
+    return fn;
+  };
+});
+function Ids(seed) {
+  if (!(this instanceof Ids)) {
+    return new Ids(seed);
+  }
+  seed = seed || [128, 36, 1];
+  this._seed = seed.length ? hat_1.rack(seed[0], seed[1], seed[2]) : seed;
+}
+Ids.prototype.next = function(element) {
+  return this._seed(element || true);
+};
+Ids.prototype.nextPrefixed = function(prefix, element) {
+  var id;
+  do {
+    id = prefix + this.next(true);
+  } while (this.assigned(id));
+  this.claim(id, element);
+  return id;
+};
+Ids.prototype.claim = function(id, element) {
+  this._seed.set(id, element || true);
+};
+Ids.prototype.assigned = function(id) {
+  return this._seed.get(id) || false;
+};
+Ids.prototype.unclaim = function(id) {
+  delete this._seed.hats[id];
+};
+Ids.prototype.clear = function() {
+  var hats = this._seed.hats, id;
+  for (id in hats) {
+    this.unclaim(id);
+  }
+};
+exports.default = Ids;

package/lib/node_modules/inherits-browser/dist/index.es.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function e(e2, t) {
+  t && (e2.super_ = t, e2.prototype = Object.create(t.prototype, { constructor: { value: e2, enumerable: false, writable: true, configurable: true } }));
+}
+exports.default = e;