@legionworks/facet 1.9.0

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

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

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

@@ -0,0 +1,19 @@
+import {
+  __name
+} from "./markdown-1s5vwkf2.js";
+
+// node_modules/mermaid/dist/chunks/mermaid.core/chunk-JWPE2WC7.mjs
+function populateCommonDb(ast, db) {
+  if (ast.accDescr) {
+    db.setAccDescription?.(ast.accDescr);
+  }
+  if (ast.accTitle) {
+    db.setAccTitle?.(ast.accTitle);
+  }
+  if (ast.title) {
+    db.setDiagramTitle?.(ast.title);
+  }
+}
+__name(populateCommonDb, "populateCommonDb");
+
+export { populateCommonDb };

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

@@ -0,0 +1,100 @@
+import {
+  getConfig2
+} from "./markdown-92n37gd4.js";
+import {
+  __name
+} from "./markdown-1s5vwkf2.js";
+
+// node_modules/mermaid/dist/chunks/mermaid.core/chunk-W5SLKNZC.mjs
+var solidStateFill = /* @__PURE__ */ __name((color) => {
+  const { handDrawnSeed } = getConfig2();
+  return {
+    fill: color,
+    hachureAngle: 120,
+    hachureGap: 4,
+    fillWeight: 2,
+    roughness: 0.7,
+    stroke: color,
+    seed: handDrawnSeed
+  };
+}, "solidStateFill");
+var compileStyles = /* @__PURE__ */ __name((node) => {
+  const stylesMap = styles2Map([
+    ...node.cssCompiledStyles || [],
+    ...node.cssStyles || [],
+    ...node.labelStyle || []
+  ]);
+  return { stylesMap, stylesArray: [...stylesMap] };
+}, "compileStyles");
+var styles2Map = /* @__PURE__ */ __name((styles) => {
+  const styleMap = /* @__PURE__ */ new Map;
+  styles.forEach((style) => {
+    const [key, value] = style.split(":");
+    styleMap.set(key.trim(), value?.trim());
+  });
+  return styleMap;
+}, "styles2Map");
+var isLabelStyle = /* @__PURE__ */ __name((key) => {
+  return key === "color" || key === "font-size" || key === "font-family" || key === "font-weight" || key === "font-style" || key === "text-decoration" || key === "text-align" || key === "text-transform" || key === "line-height" || key === "letter-spacing" || key === "word-spacing" || key === "text-shadow" || key === "text-overflow" || key === "white-space" || key === "word-wrap" || key === "word-break" || key === "overflow-wrap" || key === "hyphens";
+}, "isLabelStyle");
+var styles2String = /* @__PURE__ */ __name((node) => {
+  const { stylesArray } = compileStyles(node);
+  const labelStyles = [];
+  const nodeStyles = [];
+  const borderStyles = [];
+  const backgroundStyles = [];
+  stylesArray.forEach((style) => {
+    const key = style[0];
+    if (isLabelStyle(key)) {
+      labelStyles.push(style.join(":") + " !important");
+    } else {
+      nodeStyles.push(style.join(":") + " !important");
+      if (key.includes("stroke")) {
+        borderStyles.push(style.join(":") + " !important");
+      }
+      if (key === "fill") {
+        backgroundStyles.push(style.join(":") + " !important");
+      }
+    }
+  });
+  return {
+    labelStyles: labelStyles.join(";"),
+    nodeStyles: nodeStyles.join(";"),
+    stylesArray,
+    borderStyles,
+    backgroundStyles
+  };
+}, "styles2String");
+var userNodeOverrides = /* @__PURE__ */ __name((node, options) => {
+  const { themeVariables, handDrawnSeed } = getConfig2();
+  const { nodeBorder, mainBkg } = themeVariables;
+  const { stylesMap } = compileStyles(node);
+  const result = Object.assign({
+    roughness: 0.7,
+    fill: stylesMap.get("fill") || mainBkg,
+    fillStyle: "hachure",
+    fillWeight: 4,
+    hachureGap: 5.2,
+    stroke: stylesMap.get("stroke") || nodeBorder,
+    seed: handDrawnSeed,
+    strokeWidth: stylesMap.get("stroke-width")?.replace("px", "") || 1.3,
+    fillLineDash: [0, 0],
+    strokeLineDash: getStrokeDashArray(stylesMap.get("stroke-dasharray"))
+  }, options);
+  return result;
+}, "userNodeOverrides");
+var getStrokeDashArray = /* @__PURE__ */ __name((strokeDasharrayStyle) => {
+  if (!strokeDasharrayStyle) {
+    return [0, 0];
+  }
+  const dashArray = strokeDasharrayStyle.trim().split(/\s+/).map(Number);
+  if (dashArray.length === 1) {
+    const val = isNaN(dashArray[0]) ? 0 : dashArray[0];
+    return [val, val];
+  }
+  const first = isNaN(dashArray[0]) ? 0 : dashArray[0];
+  const second = isNaN(dashArray[1]) ? 0 : dashArray[1];
+  return [first, second];
+}, "getStrokeDashArray");
+
+export { solidStateFill, compileStyles, isLabelStyle, styles2String, userNodeOverrides };

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

@@ -0,0 +1,125 @@
+import {
+  __name
+} from "./markdown-dz3z5w30.js";
+import {
+  __require
+} from "./markdown-809k7q41.js";
+
+// node_modules/@mermaid-js/parser/dist/mermaid-parser.core.mjs
+var parsers = {};
+var initializers = {
+  info: /* @__PURE__ */ __name(async () => {
+    const { createInfoServices: createInfoServices2 } = await import("./info-DKCQHKI2-mpt80jd3.js");
+    const parser = createInfoServices2().Info.parser.LangiumParser;
+    parsers.info = parser;
+  }, "info"),
+  packet: /* @__PURE__ */ __name(async () => {
+    const { createPacketServices: createPacketServices2 } = await import("./packet-7NZHBO7P-xppm5913.js");
+    const parser = createPacketServices2().Packet.parser.LangiumParser;
+    parsers.packet = parser;
+  }, "packet"),
+  pie: /* @__PURE__ */ __name(async () => {
+    const { createPieServices: createPieServices2 } = await import("./pie-RZYD4A2V-hnbxk152.js");
+    const parser = createPieServices2().Pie.parser.LangiumParser;
+    parsers.pie = parser;
+  }, "pie"),
+  treeView: /* @__PURE__ */ __name(async () => {
+    const { createTreeViewServices: createTreeViewServices2 } = await import("./treeView-QDETBFTQ-hcx7n0vt.js");
+    const parser = createTreeViewServices2().TreeView.parser.LangiumParser;
+    parsers.treeView = parser;
+  }, "treeView"),
+  architecture: /* @__PURE__ */ __name(async () => {
+    const { createArchitectureServices: createArchitectureServices2 } = await import("./architecture-TIHT7OUA-cvdjn7dt.js");
+    const parser = createArchitectureServices2().Architecture.parser.LangiumParser;
+    parsers.architecture = parser;
+  }, "architecture"),
+  gitGraph: /* @__PURE__ */ __name(async () => {
+    const { createGitGraphServices: createGitGraphServices2 } = await import("./gitGraph-TEB2WS4Q-j6kw0naa.js");
+    const parser = createGitGraphServices2().GitGraph.parser.LangiumParser;
+    parsers.gitGraph = parser;
+  }, "gitGraph"),
+  eventmodeling: /* @__PURE__ */ __name(async () => {
+    const { createEventModelingServices: createEventModelingServices2 } = await import("./eventmodeling-45OFAUF4-sg07qr0c.js");
+    const parser = createEventModelingServices2().EventModel.parser.LangiumParser;
+    parsers.eventmodeling = parser;
+  }, "eventmodeling"),
+  radar: /* @__PURE__ */ __name(async () => {
+    const { createRadarServices: createRadarServices2 } = await import("./radar-I7S5WNFK-ewqd27se.js");
+    const parser = createRadarServices2().Radar.parser.LangiumParser;
+    parsers.radar = parser;
+  }, "radar"),
+  railroad: /* @__PURE__ */ __name(async () => {
+    const { createRailroadServices: createRailroadServices2 } = await import("./railroad-3IZDKUUU-5hy4bdx3.js");
+    const parser = createRailroadServices2().Railroad.parser.LangiumParser;
+    parsers.railroad = parser;
+  }, "railroad"),
+  railroadEbnf: /* @__PURE__ */ __name(async () => {
+    const { createRailroadEbnfServices: createRailroadEbnfServices2 } = await import("./railroad-ebnf-EBAXGLYW-6b9c3zeh.js");
+    const parser = createRailroadEbnfServices2().RailroadEbnf.parser.LangiumParser;
+    parsers.railroadEbnf = parser;
+  }, "railroadEbnf"),
+  railroadAbnf: /* @__PURE__ */ __name(async () => {
+    const { createRailroadAbnfServices: createRailroadAbnfServices2 } = await import("./railroad-abnf-AHOZXSZD-bh5sxz0d.js");
+    const parser = createRailroadAbnfServices2().RailroadAbnf.parser.LangiumParser;
+    parsers.railroadAbnf = parser;
+  }, "railroadAbnf"),
+  railroadPeg: /* @__PURE__ */ __name(async () => {
+    const { createRailroadPegServices: createRailroadPegServices2 } = await import("./railroad-peg-LSFZ7HO6-avc8v39s.js");
+    const parser = createRailroadPegServices2().RailroadPeg.parser.LangiumParser;
+    parsers.railroadPeg = parser;
+  }, "railroadPeg"),
+  treemap: /* @__PURE__ */ __name(async () => {
+    const { createTreemapServices: createTreemapServices2 } = await import("./treemap-6X3UGDF4-av02skdw.js");
+    const parser = createTreemapServices2().Treemap.parser.LangiumParser;
+    parsers.treemap = parser;
+  }, "treemap"),
+  wardley: /* @__PURE__ */ __name(async () => {
+    const { createWardleyServices: createWardleyServices2 } = await import("./wardley-OPB4EBWU-njsp6e40.js");
+    const parser = createWardleyServices2().Wardley.parser.LangiumParser;
+    parsers.wardley = parser;
+  }, "wardley"),
+  cynefin: /* @__PURE__ */ __name(async () => {
+    const { createCynefinServices: createCynefinServices2 } = await import("./cynefin-VYW2F7L2-tqjv913d.js");
+    const parser = createCynefinServices2().Cynefin.parser.LangiumParser;
+    parsers.cynefin = parser;
+  }, "cynefin")
+};
+async function parse(diagramType, text) {
+  const initializer = initializers[diagramType];
+  if (!initializer) {
+    throw new Error(`Unknown diagram type: ${diagramType}`);
+  }
+  if (!parsers[diagramType]) {
+    await initializer();
+  }
+  const parser = parsers[diagramType];
+  const result = parser.parse(text);
+  if (result.lexerErrors.length > 0 || result.parserErrors.length > 0) {
+    throw new MermaidParseError(result);
+  }
+  return result.value;
+}
+__name(parse, "parse");
+var MermaidParseError = class extends Error {
+  constructor(result) {
+    const lexerErrors = result.lexerErrors.map((err) => {
+      const line = err.line !== undefined && !isNaN(err.line) ? err.line : "?";
+      const column = err.column !== undefined && !isNaN(err.column) ? err.column : "?";
+      return `Lexer error on line ${line}, column ${column}: ${err.message}`;
+    }).join(`
+`);
+    const parserErrors = result.parserErrors.map((err) => {
+      const line = err.token.startLine !== undefined && !isNaN(err.token.startLine) ? err.token.startLine : "?";
+      const column = err.token.startColumn !== undefined && !isNaN(err.token.startColumn) ? err.token.startColumn : "?";
+      return `Parse error on line ${line}, column ${column}: ${err.message}`;
+    }).join(`
+`);
+    super(`Parsing failed: ${lexerErrors} ${parserErrors}`);
+    this.result = result;
+  }
+  static {
+    __name(this, "MermaidParseError");
+  }
+};
+
+export { parse, MermaidParseError };

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

@@ -0,0 +1,243 @@
+// src/shared/contracts/renderers.ts
+var RENDERERS = ["svg", "canvas"];
+function isRenderer(value) {
+  return typeof value === "string" && RENDERERS.includes(value);
+}
+
+// src/shared/html/policy.ts
+var HTML_DENIED_ELEMENTS = [
+  "script",
+  "iframe",
+  "object",
+  "embed",
+  "form",
+  "link",
+  "meta",
+  "base",
+  "style"
+];
+var HTML_STRUCTURAL_GROUPS = {
+  headings: ["h1", "h2", "h3", "h4", "h5", "h6"],
+  tables: ["table"],
+  lists: ["ul", "ol"],
+  images: ["img"],
+  canvases: ["canvas"]
+};
+var HTML_URL_BEARING_ATTRIBUTES = {
+  img: ["src", "srcset"],
+  source: ["srcset"],
+  a: ["href"]
+};
+var HTML_ALLOWED_ANCHOR_SCHEMES = ["https:", "mailto:"];
+var HTML_ALLOWED_IMAGE_SCHEMES = ["data:", "https:"];
+function htmlUrlBearingElement(name) {
+  const normalized = name.toLowerCase();
+  return normalized in HTML_URL_BEARING_ATTRIBUTES ? normalized : null;
+}
+function isHtmlDeniedElement(name) {
+  return HTML_DENIED_ELEMENTS.includes(name.toLowerCase());
+}
+function isHtmlUrlBearingAttribute(elementName, attributeName) {
+  const element = htmlUrlBearingElement(elementName);
+  return element !== null && HTML_URL_BEARING_ATTRIBUTES[element].includes(attributeName.toLowerCase());
+}
+function isHtmlUrlAttributeName(attributeName) {
+  const normalized = attributeName.toLowerCase();
+  return Object.values(HTML_URL_BEARING_ATTRIBUTES).some((attributes) => attributes.includes(normalized));
+}
+function isHtmlEventHandlerAttribute(name) {
+  return name.toLowerCase().startsWith("on");
+}
+function isHtmlInlineStyleAttribute(name) {
+  return name.toLowerCase() === "style";
+}
+function isAllowedHtmlUrl(elementName, attributeName, value) {
+  const element = htmlUrlBearingElement(elementName);
+  if (element === null || !isHtmlUrlBearingAttribute(element, attributeName))
+    return false;
+  const trimmed = value.trim();
+  if (trimmed.startsWith("//"))
+    return false;
+  let url;
+  try {
+    url = new URL(trimmed, "https://facet.invalid/");
+  } catch {
+    return false;
+  }
+  const scheme = url.protocol.toLowerCase();
+  switch (element) {
+    case "img":
+    case "source":
+      if (scheme === "data:")
+        return isImageDataUrl(url);
+      return HTML_ALLOWED_IMAGE_SCHEMES.includes(scheme);
+    case "a":
+      return HTML_ALLOWED_ANCHOR_SCHEMES.includes(scheme);
+    default: {
+      const _ = element;
+      return _;
+    }
+  }
+}
+function isImageDataUrl(url) {
+  const comma = url.pathname.indexOf(",");
+  if (comma < 0)
+    return false;
+  const metadata = url.pathname.slice(0, comma);
+  const separator = metadata.indexOf(";");
+  const encodedMediaType = (separator < 0 ? metadata : metadata.slice(0, separator)).trim();
+  let mediaType;
+  try {
+    mediaType = decodeURIComponent(encodedMediaType).toLowerCase();
+  } catch {
+    return false;
+  }
+  const parts = mediaType.split("/");
+  return parts.length === 2 && parts[0] === "image" && parts[1].length > 0;
+}
+
+// src/shared/tsx/execution.ts
+var TSX_EXECUTION_MODES = ["static", "interactive"];
+function isTsxExecutionMode(value) {
+  return typeof value === "string" && TSX_EXECUTION_MODES.includes(value);
+}
+
+// src/gallery-web/frame/renderers/registry.ts
+class FacetRenderError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "FacetRenderError";
+  }
+}
+function decodeArtifactBytes(bytes) {
+  return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+}
+var RENDER_ERROR_ATTRIBUTE = "data-facet-error";
+var RENDER_ERROR_ELEMENT = "facet-error";
+function renderErrorMessage(value) {
+  if (value instanceof Error)
+    return value.message;
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "object" && value !== null) {
+    const event = value;
+    for (const candidate of [event.reason, event.error, event.message]) {
+      if (candidate instanceof Error)
+        return candidate.message;
+      if (typeof candidate === "string")
+        return candidate;
+      if (typeof candidate === "object" && candidate !== null && "message" in candidate && typeof candidate.message === "string") {
+        return candidate.message;
+      }
+    }
+  }
+  return "interactive TSX runtime error";
+}
+function appendRenderError(container, value) {
+  const el = container.ownerDocument.createElement(RENDER_ERROR_ELEMENT);
+  el.setAttribute(RENDER_ERROR_ATTRIBUTE, "true");
+  el.textContent = renderErrorMessage(value);
+  container.appendChild(el);
+}
+var RENDERER_ROOT_SELECTOR = 'svg[data-facet-renderer-root="true"]';
+var MARKED_ROOT_SELECTOR = '[data-facet-renderer-root="true"]';
+var RENDERER_GRAPH_ATTRIBUTE = "data-facet-renderer-graph";
+function safeSelectorElementsWithin(scope, selector) {
+  try {
+    return Array.from(scope.querySelectorAll(selector));
+  } catch {
+    return [];
+  }
+}
+function safeSelectorElements(selector) {
+  return safeSelectorElementsWithin(document, selector);
+}
+function hasMarkedRootAncestor(root, roots) {
+  let parent = root.parentElement;
+  while (parent !== null) {
+    if (roots.has(parent))
+      return true;
+    parent = parent.parentElement;
+  }
+  return false;
+}
+function nonDegenerateViewBox(svg) {
+  const parts = (svg.getAttribute("viewBox") ?? "").trim().split(/[\s,]+/).map((part) => Number.parseFloat(part));
+  if (parts.length !== 4)
+    return false;
+  const [, , width, height] = parts;
+  return Number.isFinite(width) && Number.isFinite(height) && width > 0 && height > 0;
+}
+function countPageShim() {
+  const markedCandidates = safeSelectorElements(RENDERER_ROOT_SELECTOR);
+  const candidateSet = new Set(markedCandidates);
+  const roots = markedCandidates.filter((root) => !hasMarkedRootAncestor(root, candidateSet));
+  const graphRoots = roots.filter((root) => root.getAttribute(RENDERER_GRAPH_ATTRIBUTE) === "true");
+  const allMarkedCandidates = safeSelectorElements(MARKED_ROOT_SELECTOR);
+  const markedSet = new Set(allMarkedCandidates);
+  const htmlRoots = allMarkedCandidates.filter((root) => root.nodeName.toLowerCase() !== "svg" && !hasMarkedRootAncestor(root, markedSet));
+  const html = htmlRoots.length === 0 ? undefined : {
+    rendererRootCount: htmlRoots.length,
+    headingCount: 0,
+    tableCount: 0,
+    listCount: 0,
+    imageCount: 0,
+    canvasCount: 0,
+    externalImageCount: 0
+  };
+  for (const root of htmlRoots) {
+    html.headingCount += safeSelectorElementsWithin(root, HTML_STRUCTURAL_GROUPS.headings.join(",")).length;
+    html.tableCount += safeSelectorElementsWithin(root, HTML_STRUCTURAL_GROUPS.tables.join(",")).length;
+    html.listCount += safeSelectorElementsWithin(root, HTML_STRUCTURAL_GROUPS.lists.join(",")).length;
+    const images = safeSelectorElementsWithin(root, HTML_STRUCTURAL_GROUPS.images.join(","));
+    html.imageCount += images.length;
+    html.externalImageCount += images.filter((image) => {
+      try {
+        return new URL(image.getAttribute("src") ?? "").protocol === "https:";
+      } catch {
+        return false;
+      }
+    }).length;
+    html.canvasCount += safeSelectorElementsWithin(root, HTML_STRUCTURAL_GROUPS.canvases.join(",")).length;
+  }
+  const mermaidNodeCount = graphRoots.reduce((count, root) => count + safeSelectorElementsWithin(root, "g.node").length, 0);
+  const opaqueRegionCount = safeSelectorElements("*").filter((element) => element.nodeName.toLowerCase() === "canvas").length;
+  return {
+    rendererRootSvgCount: roots.length,
+    graphCount: graphRoots.length,
+    mermaidNodeCount,
+    visibleSvgCount: roots.filter(nonDegenerateViewBox).length,
+    opaqueRegionCount,
+    externalImageCount: html?.externalImageCount ?? 0,
+    errorCount: safeSelectorElements("[data-facet-error]").length,
+    ...html === undefined ? {} : { html }
+  };
+}
+function createRendererRegistry(entries) {
+  const registry = new Map(entries);
+  return {
+    get(type) {
+      return registry.get(type);
+    }
+  };
+}
+async function dispatchRender(registry, ctx, payload) {
+  if (!isRenderer(payload.renderer)) {
+    throw new FacetRenderError(`Artifact renderer '${payload.renderer}' is not supported in this frame`, "invalid_request");
+  }
+  const renderer = registry.get(payload.artifactType);
+  if (renderer === undefined) {
+    throw new FacetRenderError(`Artifact type '${payload.artifactType}' has no renderer in this frame`, "unsupported_reserved_type");
+  }
+  if (payload.artifactType === "tsx" && !isTsxExecutionMode(payload.execution)) {
+    throw new FacetRenderError("TSX artifact payload is missing execution", "invalid_request");
+  }
+  if (payload.artifactType !== "tsx" && payload.execution === "interactive") {
+    throw new FacetRenderError("Interactive execution is only supported for TSX artifacts", "invalid_request");
+  }
+  await renderer(ctx, payload.bytes, payload.renderer, payload.execution);
+}
+
+export { isTsxExecutionMode, isRenderer, isHtmlDeniedElement, isHtmlUrlBearingAttribute, isHtmlUrlAttributeName, isHtmlEventHandlerAttribute, isHtmlInlineStyleAttribute, isAllowedHtmlUrl, FacetRenderError, decodeArtifactBytes, RENDER_ERROR_ATTRIBUTE, appendRenderError, countPageShim, createRendererRegistry, dispatchRender };