@fecp/designer 5.6.6 → 5.6.9

package/lib/node_modules/mdurl/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const decode = require("./lib/decode.js");
+const encode = require("./lib/encode.js");
+const format = require("./lib/format.js");
+const parse = require("./lib/parse.js");
+exports.decode = decode.default;
+exports.encode = encode.default;
+exports.format = format.default;
+exports.parse = parse.default;

package/lib/node_modules/mdurl/lib/decode.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const decodeCache = {};
+function getDecodeCache(exclude) {
+  let cache = decodeCache[exclude];
+  if (cache) {
+    return cache;
+  }
+  cache = decodeCache[exclude] = [];
+  for (let i = 0; i < 128; i++) {
+    const ch = String.fromCharCode(i);
+    cache.push(ch);
+  }
+  for (let i = 0; i < exclude.length; i++) {
+    const ch = exclude.charCodeAt(i);
+    cache[ch] = "%" + ("0" + ch.toString(16).toUpperCase()).slice(-2);
+  }
+  return cache;
+}
+function decode(string, exclude) {
+  if (typeof exclude !== "string") {
+    exclude = decode.defaultChars;
+  }
+  const cache = getDecodeCache(exclude);
+  return string.replace(/(%[a-f0-9]{2})+/gi, function(seq) {
+    let result = "";
+    for (let i = 0, l = seq.length; i < l; i += 3) {
+      const b1 = parseInt(seq.slice(i + 1, i + 3), 16);
+      if (b1 < 128) {
+        result += cache[b1];
+        continue;
+      }
+      if ((b1 & 224) === 192 && i + 3 < l) {
+        const b2 = parseInt(seq.slice(i + 4, i + 6), 16);
+        if ((b2 & 192) === 128) {
+          const chr = b1 << 6 & 1984 | b2 & 63;
+          if (chr < 128) {
+            result += "��";
+          } else {
+            result += String.fromCharCode(chr);
+          }
+          i += 3;
+          continue;
+        }
+      }
+      if ((b1 & 240) === 224 && i + 6 < l) {
+        const b2 = parseInt(seq.slice(i + 4, i + 6), 16);
+        const b3 = parseInt(seq.slice(i + 7, i + 9), 16);
+        if ((b2 & 192) === 128 && (b3 & 192) === 128) {
+          const chr = b1 << 12 & 61440 | b2 << 6 & 4032 | b3 & 63;
+          if (chr < 2048 || chr >= 55296 && chr <= 57343) {
+            result += "���";
+          } else {
+            result += String.fromCharCode(chr);
+          }
+          i += 6;
+          continue;
+        }
+      }
+      if ((b1 & 248) === 240 && i + 9 < l) {
+        const b2 = parseInt(seq.slice(i + 4, i + 6), 16);
+        const b3 = parseInt(seq.slice(i + 7, i + 9), 16);
+        const b4 = parseInt(seq.slice(i + 10, i + 12), 16);
+        if ((b2 & 192) === 128 && (b3 & 192) === 128 && (b4 & 192) === 128) {
+          let chr = b1 << 18 & 1835008 | b2 << 12 & 258048 | b3 << 6 & 4032 | b4 & 63;
+          if (chr < 65536 || chr > 1114111) {
+            result += "����";
+          } else {
+            chr -= 65536;
+            result += String.fromCharCode(55296 + (chr >> 10), 56320 + (chr & 1023));
+          }
+          i += 9;
+          continue;
+        }
+      }
+      result += "�";
+    }
+    return result;
+  });
+}
+decode.defaultChars = ";/?:@&=+$,#";
+decode.componentChars = "";
+exports.default = decode;

package/lib/node_modules/mdurl/lib/encode.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const encodeCache = {};
+function getEncodeCache(exclude) {
+  let cache = encodeCache[exclude];
+  if (cache) {
+    return cache;
+  }
+  cache = encodeCache[exclude] = [];
+  for (let i = 0; i < 128; i++) {
+    const ch = String.fromCharCode(i);
+    if (/^[0-9a-z]$/i.test(ch)) {
+      cache.push(ch);
+    } else {
+      cache.push("%" + ("0" + i.toString(16).toUpperCase()).slice(-2));
+    }
+  }
+  for (let i = 0; i < exclude.length; i++) {
+    cache[exclude.charCodeAt(i)] = exclude[i];
+  }
+  return cache;
+}
+function encode(string, exclude, keepEscaped) {
+  if (typeof exclude !== "string") {
+    keepEscaped = exclude;
+    exclude = encode.defaultChars;
+  }
+  if (typeof keepEscaped === "undefined") {
+    keepEscaped = true;
+  }
+  const cache = getEncodeCache(exclude);
+  let result = "";
+  for (let i = 0, l = string.length; i < l; i++) {
+    const code = string.charCodeAt(i);
+    if (keepEscaped && code === 37 && i + 2 < l) {
+      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {
+        result += string.slice(i, i + 3);
+        i += 2;
+        continue;
+      }
+    }
+    if (code < 128) {
+      result += cache[code];
+      continue;
+    }
+    if (code >= 55296 && code <= 57343) {
+      if (code >= 55296 && code <= 56319 && i + 1 < l) {
+        const nextCode = string.charCodeAt(i + 1);
+        if (nextCode >= 56320 && nextCode <= 57343) {
+          result += encodeURIComponent(string[i] + string[i + 1]);
+          i++;
+          continue;
+        }
+      }
+      result += "%EF%BF%BD";
+      continue;
+    }
+    result += encodeURIComponent(string[i]);
+  }
+  return result;
+}
+encode.defaultChars = ";/?:@&=+$,-_.!~*'()#";
+encode.componentChars = "-_.!~*'()";
+exports.default = encode;

package/lib/node_modules/mdurl/lib/format.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function format(url) {
+  let result = "";
+  result += url.protocol || "";
+  result += url.slashes ? "//" : "";
+  result += url.auth ? url.auth + "@" : "";
+  if (url.hostname && url.hostname.indexOf(":") !== -1) {
+    result += "[" + url.hostname + "]";
+  } else {
+    result += url.hostname || "";
+  }
+  result += url.port ? ":" + url.port : "";
+  result += url.pathname || "";
+  result += url.search || "";
+  result += url.hash || "";
+  return result;
+}
+exports.default = format;

package/lib/node_modules/mdurl/lib/parse.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function Url() {
+  this.protocol = null;
+  this.slashes = null;
+  this.auth = null;
+  this.port = null;
+  this.hostname = null;
+  this.hash = null;
+  this.search = null;
+  this.pathname = null;
+}
+const protocolPattern = /^([a-z0-9.+-]+:)/i;
+const portPattern = /:[0-9]*$/;
+const simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/;
+const delims = ["<", ">", '"', "`", " ", "\r", "\n", "	"];
+const unwise = ["{", "}", "|", "\\", "^", "`"].concat(delims);
+const autoEscape = ["'"].concat(unwise);
+const nonHostChars = ["%", "/", "?", ";", "#"].concat(autoEscape);
+const hostEndingChars = ["/", "?", "#"];
+const hostnameMaxLen = 255;
+const hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;
+const hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;
+const hostlessProtocol = {
+  javascript: true,
+  "javascript:": true
+};
+const slashedProtocol = {
+  http: true,
+  https: true,
+  ftp: true,
+  gopher: true,
+  file: true,
+  "http:": true,
+  "https:": true,
+  "ftp:": true,
+  "gopher:": true,
+  "file:": true
+};
+function urlParse(url, slashesDenoteHost) {
+  if (url && url instanceof Url) return url;
+  const u = new Url();
+  u.parse(url, slashesDenoteHost);
+  return u;
+}
+Url.prototype.parse = function(url, slashesDenoteHost) {
+  let lowerProto, hec, slashes;
+  let rest = url;
+  rest = rest.trim();
+  if (!slashesDenoteHost && url.split("#").length === 1) {
+    const simplePath = simplePathPattern.exec(rest);
+    if (simplePath) {
+      this.pathname = simplePath[1];
+      if (simplePath[2]) {
+        this.search = simplePath[2];
+      }
+      return this;
+    }
+  }
+  let proto = protocolPattern.exec(rest);
+  if (proto) {
+    proto = proto[0];
+    lowerProto = proto.toLowerCase();
+    this.protocol = proto;
+    rest = rest.substr(proto.length);
+  }
+  if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
+    slashes = rest.substr(0, 2) === "//";
+    if (slashes && !(proto && hostlessProtocol[proto])) {
+      rest = rest.substr(2);
+      this.slashes = true;
+    }
+  }
+  if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
+    let hostEnd = -1;
+    for (let i = 0; i < hostEndingChars.length; i++) {
+      hec = rest.indexOf(hostEndingChars[i]);
+      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
+        hostEnd = hec;
+      }
+    }
+    let auth, atSign;
+    if (hostEnd === -1) {
+      atSign = rest.lastIndexOf("@");
+    } else {
+      atSign = rest.lastIndexOf("@", hostEnd);
+    }
+    if (atSign !== -1) {
+      auth = rest.slice(0, atSign);
+      rest = rest.slice(atSign + 1);
+      this.auth = auth;
+    }
+    hostEnd = -1;
+    for (let i = 0; i < nonHostChars.length; i++) {
+      hec = rest.indexOf(nonHostChars[i]);
+      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
+        hostEnd = hec;
+      }
+    }
+    if (hostEnd === -1) {
+      hostEnd = rest.length;
+    }
+    if (rest[hostEnd - 1] === ":") {
+      hostEnd--;
+    }
+    const host = rest.slice(0, hostEnd);
+    rest = rest.slice(hostEnd);
+    this.parseHost(host);
+    this.hostname = this.hostname || "";
+    const ipv6Hostname = this.hostname[0] === "[" && this.hostname[this.hostname.length - 1] === "]";
+    if (!ipv6Hostname) {
+      const hostparts = this.hostname.split(/\./);
+      for (let i = 0, l = hostparts.length; i < l; i++) {
+        const part = hostparts[i];
+        if (!part) {
+          continue;
+        }
+        if (!part.match(hostnamePartPattern)) {
+          let newpart = "";
+          for (let j = 0, k = part.length; j < k; j++) {
+            if (part.charCodeAt(j) > 127) {
+              newpart += "x";
+            } else {
+              newpart += part[j];
+            }
+          }
+          if (!newpart.match(hostnamePartPattern)) {
+            const validParts = hostparts.slice(0, i);
+            const notHost = hostparts.slice(i + 1);
+            const bit = part.match(hostnamePartStart);
+            if (bit) {
+              validParts.push(bit[1]);
+              notHost.unshift(bit[2]);
+            }
+            if (notHost.length) {
+              rest = notHost.join(".") + rest;
+            }
+            this.hostname = validParts.join(".");
+            break;
+          }
+        }
+      }
+    }
+    if (this.hostname.length > hostnameMaxLen) {
+      this.hostname = "";
+    }
+    if (ipv6Hostname) {
+      this.hostname = this.hostname.substr(1, this.hostname.length - 2);
+    }
+  }
+  const hash = rest.indexOf("#");
+  if (hash !== -1) {
+    this.hash = rest.substr(hash);
+    rest = rest.slice(0, hash);
+  }
+  const qm = rest.indexOf("?");
+  if (qm !== -1) {
+    this.search = rest.substr(qm);
+    rest = rest.slice(0, qm);
+  }
+  if (rest) {
+    this.pathname = rest;
+  }
+  if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {
+    this.pathname = "";
+  }
+  return this;
+};
+Url.prototype.parseHost = function(host) {
+  let port = portPattern.exec(host);
+  if (port) {
+    port = port[0];
+    if (port !== ":") {
+      this.port = port.substr(1);
+    }
+    host = host.substr(0, host.length - port.length);
+  }
+  if (host) {
+    this.hostname = host;
+  }
+};
+exports.default = urlParse;

package/lib/node_modules/mermaid/dist/chunks/mermaid.core/abnfDiagram-VRR7QNED.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const chunkMOJQB5TN = require("./chunk-MOJQB5TN.js");
+const chunkJWPE2WC7 = require("./chunk-JWPE2WC7.js");
+require("./chunk-WYO6CB5R.js");
+const chunkY2CYZVJY = require("./chunk-Y2CYZVJY.js");
+require("../../../../d3-transition/src/selection/index.js");
+require("../../../../d3-zoom/src/transform.js");
+const chunkX3CZISLH = require("./chunk-X3CZISLH.js");
+const mermaidParser_core = require("../../../../@mermaid-js/parser/dist/mermaid-parser.core.js");
+const chunk5HE753X5 = require("../../../../@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-5HE753X5.js");
+var langiumParser = chunk5HE753X5.createRailroadAbnfServices().RailroadAbnf.parser.LangiumParser;
+var transformAlternation = /* @__PURE__ */ chunkY2CYZVJY.__name((alt) => {
+  const alternatives = alt.alternatives.map(transformConcatenation);
+  if (alternatives.length === 1) {
+    return alternatives[0];
+  }
+  return {
+    type: "choice",
+    alternatives
+  };
+}, "transformAlternation");
+var transformConcatenation = /* @__PURE__ */ chunkY2CYZVJY.__name((concat) => {
+  const elements = concat.elements.map(transformElement);
+  if (elements.length === 1) {
+    return elements[0];
+  }
+  return {
+    type: "sequence",
+    elements
+  };
+}, "transformConcatenation");
+var parseRepeat = /* @__PURE__ */ chunkY2CYZVJY.__name((repeat) => {
+  if (repeat.includes("*")) {
+    const [minStr, maxStr] = repeat.split("*");
+    const min = minStr ? parseInt(minStr, 10) : 0;
+    const max = maxStr ? parseInt(maxStr, 10) : Infinity;
+    return { min, max };
+  }
+  const exact = parseInt(repeat, 10);
+  return { min: exact, max: exact };
+}, "parseRepeat");
+var transformElement = /* @__PURE__ */ chunkY2CYZVJY.__name((element) => {
+  const inner = transformPrimary(element.primary);
+  if (!element.repeat) {
+    return inner;
+  }
+  const { min, max } = parseRepeat(element.repeat);
+  if (min === 0 && max === 1) {
+    return { type: "optional", element: inner };
+  }
+  return {
+    type: "repetition",
+    element: inner,
+    min,
+    max
+  };
+}, "transformElement");
+var transformPrimary = /* @__PURE__ */ chunkY2CYZVJY.__name((primary) => {
+  switch (primary.$type) {
+    case "AbnfStringLiteral":
+      return {
+        type: "terminal",
+        value: primary.value
+      };
+    case "AbnfNumVal":
+      return {
+        type: "terminal",
+        value: primary.value
+      };
+    case "AbnfRuleName":
+      return {
+        type: "nonterminal",
+        name: primary.name
+      };
+    case "AbnfGroup":
+      return transformAlternation(primary.element);
+    case "AbnfOptionalGroup":
+      return {
+        type: "optional",
+        element: transformAlternation(primary.element)
+      };
+    default:
+      throw new Error(`Unsupported ABNF primary node: ${primary.$type}`);
+  }
+}, "transformPrimary");
+var transformRule = /* @__PURE__ */ chunkY2CYZVJY.__name((rule) => {
+  return {
+    name: rule.name,
+    definition: transformAlternation(rule.definition)
+  };
+}, "transformRule");
+var populateDb = /* @__PURE__ */ chunkY2CYZVJY.__name((ast) => {
+  chunkJWPE2WC7.populateCommonDb(ast, chunkMOJQB5TN.db);
+  if (ast.title) {
+    chunkMOJQB5TN.db.setTitle(ast.title);
+  }
+  ast.rules.map((rule) => chunkMOJQB5TN.db.addRule(transformRule(rule)));
+}, "populateDb");
+var parser = {
+  parse: /* @__PURE__ */ chunkY2CYZVJY.__name((input) => {
+    chunkMOJQB5TN.db.clear();
+    chunkX3CZISLH.log.debug("[ABNF Parser] Starting Langium parse");
+    const result = langiumParser.parse(input);
+    if (result.lexerErrors.length > 0 || result.parserErrors.length > 0) {
+      throw new mermaidParser_core.MermaidParseError(result);
+    }
+    const ast = result.value;
+    chunkX3CZISLH.log.debug("[ABNF Parser] Parsed rules:", ast.rules.length);
+    populateDb(ast);
+    chunkX3CZISLH.log.debug("[ABNF Parser] Parse complete");
+  }, "parse"),
+  parser: {
+    yy: chunkMOJQB5TN.db
+  }
+};
+var diagram = {
+  parser,
+  db: chunkMOJQB5TN.db,
+  renderer: chunkMOJQB5TN.renderer,
+  styles: chunkMOJQB5TN.getStyles
+};
+exports.diagram = diagram;