@legionworks/facet 1.9.0

package/dist/gallery/frame/chunks/markdown-k8xkn8mw.js

@@ -0,0 +1,56 @@
+import {
+  AbstractMermaidTokenBuilder,
+  AbstractMermaidValueConverter,
+  ArchitectureGrammarGeneratedModule,
+  EmptyFileSystem,
+  MermaidGeneratedSharedModule,
+  __name,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./markdown-dz3z5w30.js";
+
+// node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-MOZMSUNE.mjs
+var ArchitectureTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "ArchitectureTokenBuilder");
+  }
+  constructor() {
+    super(["architecture"]);
+  }
+};
+var ArchitectureValueConverter = class extends AbstractMermaidValueConverter {
+  static {
+    __name(this, "ArchitectureValueConverter");
+  }
+  runCustomConverter(rule, input, _cstNode) {
+    if (rule.name === "ARCH_ICON") {
+      return input.replace(/[()]/g, "").trim();
+    } else if (rule.name === "ARCH_TEXT_ICON") {
+      return input.replace(/["()]/g, "");
+    } else if (rule.name === "ARCH_TITLE") {
+      let result = input.replace(/^\[|]$/g, "").trim();
+      if (result.startsWith('"') && result.endsWith('"') || result.startsWith("'") && result.endsWith("'")) {
+        result = result.slice(1, -1);
+        result = result.replace(/\\"/g, '"').replace(/\\'/g, "'");
+      }
+      return result.trim();
+    }
+    return;
+  }
+};
+var ArchitectureModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name(() => new ArchitectureTokenBuilder, "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name(() => new ArchitectureValueConverter, "ValueConverter")
+  }
+};
+function createArchitectureServices(context = EmptyFileSystem) {
+  const shared = inject(createDefaultSharedCoreModule(context), MermaidGeneratedSharedModule);
+  const Architecture = inject(createDefaultCoreModule({ shared }), ArchitectureGrammarGeneratedModule, ArchitectureModule);
+  shared.ServiceRegistry.register(Architecture);
+  return { shared, Architecture };
+}
+__name(createArchitectureServices, "createArchitectureServices");
+
+export { ArchitectureModule, createArchitectureServices };

package/dist/gallery/frame/chunks/markdown-m7frq8x8.js

@@ -0,0 +1,112 @@
+import {
+  __name
+} from "./markdown-1s5vwkf2.js";
+
+// node_modules/mermaid/dist/chunks/mermaid.core/chunk-7BUUIJ7U.mjs
+var computeLabelTransform = /* @__PURE__ */ __name((bbox, useHtmlLabels) => {
+  if (useHtmlLabels) {
+    return "translate(" + -bbox.width / 2 + ", " + -bbox.height / 2 + ")";
+  }
+  const x = bbox.x ?? 0;
+  const y = bbox.y ?? 0;
+  return "translate(" + -(x + bbox.width / 2) + ", " + -(y + bbox.height / 2) + ")";
+}, "computeLabelTransform");
+var markerOffsets = {
+  aggregation: 17.25,
+  extension: 17.25,
+  composition: 17.25,
+  dependency: 6,
+  lollipop: 13.5,
+  arrow_point: 4,
+  arrow_barb: 0,
+  arrow_barb_neo: 5.5
+};
+var markerOffsets2 = {
+  arrow_point: 4,
+  arrow_cross: 12.5,
+  arrow_circle: 12.5
+};
+function calculateDeltaAndAngle(point1, point2) {
+  if (point1 === undefined || point2 === undefined) {
+    return { angle: 0, deltaX: 0, deltaY: 0 };
+  }
+  point1 = pointTransformer(point1);
+  point2 = pointTransformer(point2);
+  const [x1, y1] = [point1.x, point1.y];
+  const [x2, y2] = [point2.x, point2.y];
+  const deltaX = x2 - x1;
+  const deltaY = y2 - y1;
+  return { angle: Math.atan(deltaY / deltaX), deltaX, deltaY };
+}
+__name(calculateDeltaAndAngle, "calculateDeltaAndAngle");
+var pointTransformer = /* @__PURE__ */ __name((data) => {
+  if (Array.isArray(data)) {
+    return { x: data[0], y: data[1] };
+  }
+  return data;
+}, "pointTransformer");
+var getLineFunctionsWithOffset = /* @__PURE__ */ __name((edge) => {
+  return {
+    x: /* @__PURE__ */ __name(function(d, i, data) {
+      let offset = 0;
+      const DIRECTION = pointTransformer(data[0]).x < pointTransformer(data[data.length - 1]).x ? "left" : "right";
+      if (i === 0 && Object.hasOwn(markerOffsets, edge.arrowTypeStart)) {
+        const { angle, deltaX } = calculateDeltaAndAngle(data[0], data[1]);
+        offset = markerOffsets[edge.arrowTypeStart] * Math.cos(angle) * (deltaX >= 0 ? 1 : -1);
+      } else if (i === data.length - 1 && Object.hasOwn(markerOffsets, edge.arrowTypeEnd)) {
+        const { angle, deltaX } = calculateDeltaAndAngle(data[data.length - 1], data[data.length - 2]);
+        offset = markerOffsets[edge.arrowTypeEnd] * Math.cos(angle) * (deltaX >= 0 ? 1 : -1);
+      }
+      const differenceToEnd = Math.abs(pointTransformer(d).x - pointTransformer(data[data.length - 1]).x);
+      const differenceInYEnd = Math.abs(pointTransformer(d).y - pointTransformer(data[data.length - 1]).y);
+      const differenceToStart = Math.abs(pointTransformer(d).x - pointTransformer(data[0]).x);
+      const differenceInYStart = Math.abs(pointTransformer(d).y - pointTransformer(data[0]).y);
+      const startMarkerHeight = markerOffsets[edge.arrowTypeStart];
+      const endMarkerHeight = markerOffsets[edge.arrowTypeEnd];
+      const extraRoom = 1;
+      if (differenceToEnd < endMarkerHeight && differenceToEnd > 0 && differenceInYEnd < endMarkerHeight) {
+        let adjustment = endMarkerHeight + extraRoom - differenceToEnd;
+        adjustment *= DIRECTION === "right" ? -1 : 1;
+        offset -= adjustment;
+      }
+      if (differenceToStart < startMarkerHeight && differenceToStart > 0 && differenceInYStart < startMarkerHeight) {
+        let adjustment = startMarkerHeight + extraRoom - differenceToStart;
+        adjustment *= DIRECTION === "right" ? -1 : 1;
+        offset += adjustment;
+      }
+      return pointTransformer(d).x + offset;
+    }, "x"),
+    y: /* @__PURE__ */ __name(function(d, i, data) {
+      let offset = 0;
+      const DIRECTION = pointTransformer(data[0]).y < pointTransformer(data[data.length - 1]).y ? "down" : "up";
+      if (i === 0 && Object.hasOwn(markerOffsets, edge.arrowTypeStart)) {
+        const { angle, deltaY } = calculateDeltaAndAngle(data[0], data[1]);
+        offset = markerOffsets[edge.arrowTypeStart] * Math.abs(Math.sin(angle)) * (deltaY >= 0 ? 1 : -1);
+      } else if (i === data.length - 1 && Object.hasOwn(markerOffsets, edge.arrowTypeEnd)) {
+        const { angle, deltaY } = calculateDeltaAndAngle(data[data.length - 1], data[data.length - 2]);
+        offset = markerOffsets[edge.arrowTypeEnd] * Math.abs(Math.sin(angle)) * (deltaY >= 0 ? 1 : -1);
+      }
+      const differenceToEnd = Math.abs(pointTransformer(d).y - pointTransformer(data[data.length - 1]).y);
+      const differenceInXEnd = Math.abs(pointTransformer(d).x - pointTransformer(data[data.length - 1]).x);
+      const differenceToStart = Math.abs(pointTransformer(d).y - pointTransformer(data[0]).y);
+      const differenceInXStart = Math.abs(pointTransformer(d).x - pointTransformer(data[0]).x);
+      const startMarkerHeight = markerOffsets[edge.arrowTypeStart];
+      const endMarkerHeight = markerOffsets[edge.arrowTypeEnd];
+      const extraRoom = 1;
+      if (differenceToEnd < endMarkerHeight && differenceToEnd > 0 && differenceInXEnd < endMarkerHeight) {
+        let adjustment = endMarkerHeight + extraRoom - differenceToEnd;
+        adjustment *= DIRECTION === "up" ? -1 : 1;
+        offset -= adjustment;
+      }
+      if (differenceToStart < startMarkerHeight && differenceToStart > 0 && differenceInXStart < startMarkerHeight) {
+        let adjustment = startMarkerHeight + extraRoom - differenceToStart;
+        adjustment *= DIRECTION === "up" ? -1 : 1;
+        offset += adjustment;
+      }
+      return pointTransformer(d).y + offset;
+    }, "y")
+  };
+}, "getLineFunctionsWithOffset");
+if (undefined) {}
+
+export { computeLabelTransform, markerOffsets, markerOffsets2, getLineFunctionsWithOffset };

package/dist/gallery/frame/chunks/markdown-p740v4qm.js

@@ -0,0 +1,36 @@
+import {
+  AbstractMermaidTokenBuilder,
+  CommonValueConverter,
+  EmptyFileSystem,
+  GitGraphGrammarGeneratedModule,
+  MermaidGeneratedSharedModule,
+  __name,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./markdown-dz3z5w30.js";
+
+// node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-CYSBUYHQ.mjs
+var GitGraphTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "GitGraphTokenBuilder");
+  }
+  constructor() {
+    super(["gitGraph"]);
+  }
+};
+var GitGraphModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name(() => new GitGraphTokenBuilder, "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name(() => new CommonValueConverter, "ValueConverter")
+  }
+};
+function createGitGraphServices(context = EmptyFileSystem) {
+  const shared = inject(createDefaultSharedCoreModule(context), MermaidGeneratedSharedModule);
+  const GitGraph = inject(createDefaultCoreModule({ shared }), GitGraphGrammarGeneratedModule, GitGraphModule);
+  shared.ServiceRegistry.register(GitGraph);
+  return { shared, GitGraph };
+}
+__name(createGitGraphServices, "createGitGraphServices");
+
+export { GitGraphModule, createGitGraphServices };

package/dist/gallery/frame/chunks/markdown-pxfeh231.js

@@ -0,0 +1,57 @@
+import {
+  AbstractMermaidTokenBuilder,
+  AbstractMermaidValueConverter,
+  EmptyFileSystem,
+  MermaidGeneratedSharedModule,
+  RailroadAbnfGrammarGeneratedModule,
+  __name,
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule,
+  inject
+} from "./markdown-dz3z5w30.js";
+
+// node_modules/@mermaid-js/parser/dist/chunks/mermaid-parser.core/chunk-5HE753X5.mjs
+var RailroadAbnfTokenBuilder = class extends AbstractMermaidTokenBuilder {
+  static {
+    __name(this, "RailroadAbnfTokenBuilder");
+  }
+  constructor() {
+    super(["railroad-abnf-beta"]);
+  }
+};
+var RailroadAbnfValueConverter = class extends AbstractMermaidValueConverter {
+  static {
+    __name(this, "RailroadAbnfValueConverter");
+  }
+  runConverter(rule, input, cstNode) {
+    const value = super.runConverter(rule, input, cstNode);
+    if (rule.name === "TITLE" && typeof value === "string") {
+      const trimmedValue = value.trim();
+      if (trimmedValue.startsWith('"') && trimmedValue.endsWith('"') || trimmedValue.startsWith("'") && trimmedValue.endsWith("'")) {
+        return trimmedValue.slice(1, -1);
+      }
+    }
+    return value;
+  }
+  runCustomConverter(rule, input, _cstNode) {
+    if (rule.name === "ABNF_STRING") {
+      return input.slice(1, -1);
+    }
+    return;
+  }
+};
+var RailroadAbnfModule = {
+  parser: {
+    TokenBuilder: /* @__PURE__ */ __name(() => new RailroadAbnfTokenBuilder, "TokenBuilder"),
+    ValueConverter: /* @__PURE__ */ __name(() => new RailroadAbnfValueConverter, "ValueConverter")
+  }
+};
+function createRailroadAbnfServices(context = EmptyFileSystem) {
+  const shared = inject(createDefaultSharedCoreModule(context), MermaidGeneratedSharedModule);
+  const RailroadAbnf = inject(createDefaultCoreModule({ shared }), RailroadAbnfGrammarGeneratedModule, RailroadAbnfModule);
+  shared.ServiceRegistry.register(RailroadAbnf);
+  return { shared, RailroadAbnf };
+}
+__name(createRailroadAbnfServices, "createRailroadAbnfServices");
+
+export { RailroadAbnfModule, createRailroadAbnfServices };

package/dist/gallery/frame/chunks/markdown-pzgd8z3s.js

@@ -0,0 +1,87 @@
+import {
+  __commonJS
+} from "./markdown-809k7q41.js";
+
+// node_modules/@braintree/sanitize-url/dist/constants.js
+var require_constants = __commonJS(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.BLANK_URL = exports.relativeFirstCharacters = exports.whitespaceEscapeCharsRegex = exports.urlSchemeRegex = exports.ctrlCharactersRegex = exports.htmlCtrlEntityRegex = exports.htmlEntitiesRegex = exports.invalidProtocolRegex = undefined;
+  exports.invalidProtocolRegex = /^([^\w]*)(javascript|data|vbscript)/im;
+  exports.htmlEntitiesRegex = /&#(\w+)(^\w|;)?/g;
+  exports.htmlCtrlEntityRegex = /&(newline|tab);/gi;
+  exports.ctrlCharactersRegex = /[\u0000-\u001F\u007F-\u009F\u2000-\u200D\uFEFF]/gim;
+  exports.urlSchemeRegex = /^.+(:|:)/gim;
+  exports.whitespaceEscapeCharsRegex = /(\\|%5[cC])((%(6[eE]|72|74))|[nrt])/g;
+  exports.relativeFirstCharacters = [".", "/"];
+  exports.BLANK_URL = "about:blank";
+});
+
+// node_modules/@braintree/sanitize-url/dist/index.js
+var require_dist = __commonJS(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.sanitizeUrl = sanitizeUrl;
+  var constants_1 = require_constants();
+  function isRelativeUrlWithoutProtocol(url) {
+    return constants_1.relativeFirstCharacters.indexOf(url[0]) > -1;
+  }
+  function decodeHtmlCharacters(str) {
+    var removedNullByte = str.replace(constants_1.ctrlCharactersRegex, "");
+    return removedNullByte.replace(constants_1.htmlEntitiesRegex, function(match, dec) {
+      return String.fromCharCode(dec);
+    });
+  }
+  function isValidUrl(url) {
+    return URL.canParse(url);
+  }
+  function decodeURI(uri) {
+    try {
+      return decodeURIComponent(uri);
+    } catch (e) {
+      return uri;
+    }
+  }
+  function sanitizeUrl(url) {
+    if (!url) {
+      return constants_1.BLANK_URL;
+    }
+    var charsToDecode;
+    var decodedUrl = decodeURI(url.trim());
+    do {
+      decodedUrl = decodeHtmlCharacters(decodedUrl).replace(constants_1.htmlCtrlEntityRegex, "").replace(constants_1.ctrlCharactersRegex, "").replace(constants_1.whitespaceEscapeCharsRegex, "").trim();
+      decodedUrl = decodeURI(decodedUrl);
+      charsToDecode = decodedUrl.match(constants_1.ctrlCharactersRegex) || decodedUrl.match(constants_1.htmlEntitiesRegex) || decodedUrl.match(constants_1.htmlCtrlEntityRegex) || decodedUrl.match(constants_1.whitespaceEscapeCharsRegex);
+    } while (charsToDecode && charsToDecode.length > 0);
+    var sanitizedUrl = decodedUrl;
+    if (!sanitizedUrl) {
+      return constants_1.BLANK_URL;
+    }
+    if (isRelativeUrlWithoutProtocol(sanitizedUrl)) {
+      return sanitizedUrl;
+    }
+    var trimmedUrl = sanitizedUrl.trimStart();
+    var urlSchemeParseResults = trimmedUrl.match(constants_1.urlSchemeRegex);
+    if (!urlSchemeParseResults) {
+      return sanitizedUrl;
+    }
+    var urlScheme = urlSchemeParseResults[0].toLowerCase().trim();
+    if (constants_1.invalidProtocolRegex.test(urlScheme)) {
+      return constants_1.BLANK_URL;
+    }
+    var backSanitized = trimmedUrl.replace(/\\/g, "/");
+    if (urlScheme === "mailto:" || urlScheme.includes("://")) {
+      return backSanitized;
+    }
+    if (urlScheme === "http:" || urlScheme === "https:") {
+      if (!isValidUrl(backSanitized)) {
+        return constants_1.BLANK_URL;
+      }
+      var url_1 = new URL(backSanitized);
+      url_1.protocol = url_1.protocol.toLowerCase();
+      url_1.hostname = url_1.hostname.toLowerCase();
+      return url_1.toString();
+    }
+    return backSanitized;
+  }
+});
+
+export { require_dist };