@legionworks/facet 1.9.0

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

@@ -0,0 +1,329 @@
+import {
+  FacetRenderError,
+  decodeArtifactBytes
+} from "./markdown-d1wfbs70.js";
+
+// src/gallery-web/frame/renderers/svg.ts
+var STRIPPED_TAGS = new Set([
+  "script",
+  "foreignobject",
+  "use",
+  "image",
+  "animate",
+  "animatetransform",
+  "animatemotion",
+  "set",
+  "audio",
+  "video",
+  "iframe",
+  "object",
+  "embed"
+]);
+var STRICT_URL_ATTRS = new Set(["href", "xlink:href", "src"]);
+var CSS_REF_ATTRS = new Set([
+  "fill",
+  "stroke",
+  "filter",
+  "mask",
+  "clip-path",
+  "marker",
+  "marker-start",
+  "marker-mid",
+  "marker-end",
+  "color-profile",
+  "cursor",
+  "background",
+  "background-image"
+]);
+var EVENT_HANDLER_RE = /^on[a-z]+$/i;
+var RENDERER_ROOT_ATTRIBUTE = "data-facet-renderer-root";
+var RENDERER_GRAPH_ATTRIBUTE = "data-facet-renderer-graph";
+var RESERVED_RENDERER_ATTRIBUTES = new Set([RENDERER_ROOT_ATTRIBUTE, RENDERER_GRAPH_ATTRIBUTE]);
+function stripCssComments(css) {
+  let clean = "";
+  let quote = "";
+  for (let index = 0;index < css.length; index += 1) {
+    const char = css[index];
+    if (quote) {
+      clean += char;
+      if (char === "\\" && index + 1 < css.length)
+        clean += css[index += 1];
+      else if (char === quote)
+        quote = "";
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      clean += char;
+      continue;
+    }
+    if (char === "/" && css[index + 1] === "*") {
+      const end = css.indexOf("*/", index + 2);
+      index = end === -1 ? css.length : end + 1;
+      continue;
+    }
+    clean += char;
+  }
+  return clean;
+}
+function canonicalizeCss(css) {
+  const uncommented = stripCssComments(css);
+  let decoded = "";
+  for (let index = 0;index < uncommented.length; index += 1) {
+    const char = uncommented[index];
+    if (char !== "\\") {
+      decoded += char;
+      continue;
+    }
+    const next = uncommented[index + 1];
+    if (next === undefined)
+      break;
+    if (next === `
+` || next === "\f") {
+      index += 1;
+      continue;
+    }
+    if (next === "\r") {
+      index += uncommented[index + 2] === `
+` ? 2 : 1;
+      continue;
+    }
+    let hex = "";
+    while (hex.length < 6 && /[0-9a-f]/i.test(uncommented[index + 1] ?? "")) {
+      hex += uncommented[index += 1];
+    }
+    if (hex) {
+      const codePoint = Number.parseInt(hex, 16);
+      decoded += codePoint === 0 || codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343 ? "�" : String.fromCodePoint(codePoint);
+      if (/\s/.test(uncommented[index + 1] ?? ""))
+        index += 1;
+      continue;
+    }
+    decoded += next;
+    index += 1;
+  }
+  return decoded.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function findClosingDelimiter(css, openIndex, open, close) {
+  let depth = 1;
+  let quote = "";
+  for (let index = openIndex + 1;index < css.length; index += 1) {
+    const char = css[index];
+    if (quote) {
+      if (char === "\\")
+        index += 1;
+      else if (char === quote)
+        quote = "";
+      continue;
+    }
+    if (char === '"' || char === "'")
+      quote = char;
+    else if (char === open)
+      depth += 1;
+    else if (char === close && --depth === 0)
+      return index;
+  }
+  return -1;
+}
+function containsUnsafeCssValue(value) {
+  const canonical = canonicalizeCss(value);
+  if (!canonical)
+    return false;
+  if (/@import\b/.test(canonical) || /(?:^|[^a-z0-9_-])expression\s*\(/.test(canonical) || /(?:^|[^a-z0-9_-])progid\s*:/.test(canonical) || /(?:^|[^a-z0-9_-])behavior\s*:/.test(canonical) || /^[a-z][a-z0-9+.-]*\s*:/.test(canonical)) {
+    return true;
+  }
+  for (let searchFrom = 0;searchFrom < canonical.length; ) {
+    const index = canonical.indexOf("url", searchFrom);
+    if (index === -1)
+      return false;
+    searchFrom = index + 3;
+    if (index > 0 && /[a-z0-9_-]/.test(canonical[index - 1]))
+      continue;
+    let openIndex = searchFrom;
+    while (canonical[openIndex] === " ")
+      openIndex += 1;
+    if (canonical[openIndex] !== "(")
+      continue;
+    const closeIndex = findClosingDelimiter(canonical, openIndex, "(", ")");
+    if (closeIndex === -1)
+      return true;
+    let argument = canonical.slice(openIndex + 1, closeIndex).trim();
+    const quote = argument[0];
+    if (quote === '"' || quote === "'") {
+      if (argument.at(-1) !== quote)
+        return true;
+      argument = argument.slice(1, -1).trim();
+    }
+    if (!argument.startsWith("#"))
+      return true;
+    searchFrom = closeIndex + 1;
+  }
+  return false;
+}
+function findDeclarationColon(css) {
+  let depth = 0;
+  let quote = "";
+  for (let index = 0;index < css.length; index += 1) {
+    const char = css[index];
+    if (quote) {
+      if (char === "\\")
+        index += 1;
+      else if (char === quote)
+        quote = "";
+      continue;
+    }
+    if (char === '"' || char === "'")
+      quote = char;
+    else if (char === "(")
+      depth += 1;
+    else if (char === ")")
+      depth = Math.max(0, depth - 1);
+    else if (char === ":" && depth === 0)
+      return index;
+  }
+  return -1;
+}
+function sanitizeCssStatement(statement) {
+  const trimmed = statement.trim();
+  if (!trimmed)
+    return "";
+  const colon = findDeclarationColon(trimmed);
+  const checkedValue = colon === -1 ? trimmed : trimmed.slice(colon + 1);
+  return containsUnsafeCssValue(checkedValue) || /@import\b/.test(canonicalizeCss(trimmed)) ? "" : trimmed;
+}
+function sanitizeCssBlock(css) {
+  let sanitized = "";
+  let start = 0;
+  let depth = 0;
+  let quote = "";
+  for (let index = 0;index < css.length; index += 1) {
+    const char = css[index];
+    if (quote) {
+      if (char === "\\")
+        index += 1;
+      else if (char === quote)
+        quote = "";
+      continue;
+    }
+    if (char === '"' || char === "'")
+      quote = char;
+    else if (char === "(")
+      depth += 1;
+    else if (char === ")")
+      depth = Math.max(0, depth - 1);
+    else if (char === ";" && depth === 0) {
+      const statement = sanitizeCssStatement(css.slice(start, index));
+      if (statement)
+        sanitized += `${statement};`;
+      start = index + 1;
+    } else if (char === "{" && depth === 0) {
+      const closeIndex = findClosingDelimiter(css, index, "{", "}");
+      const prelude = css.slice(start, index).trim();
+      if (closeIndex === -1)
+        return sanitized;
+      if (!containsUnsafeCssValue(prelude) && !/@import\b/.test(canonicalizeCss(prelude))) {
+        sanitized += `${prelude}{${sanitizeCssBlock(css.slice(index + 1, closeIndex))}}`;
+      }
+      index = closeIndex;
+      start = closeIndex + 1;
+    }
+  }
+  const trailing = sanitizeCssStatement(css.slice(start));
+  return trailing ? sanitized + trailing : sanitized;
+}
+function sanitizeCssText(css) {
+  return sanitizeCssBlock(stripCssComments(css));
+}
+function sanitizeSvgDocument(doc) {
+  const all = Array.from(doc.querySelectorAll("*"));
+  for (const el of all) {
+    if (STRIPPED_TAGS.has(el.localName.toLowerCase())) {
+      el.parentNode?.removeChild(el);
+      continue;
+    }
+    for (const attr of Array.from(el.attributes ?? [])) {
+      const name = attr.name.toLowerCase();
+      const localName = (attr.localName || attr.name).split(":").pop()?.toLowerCase() ?? "";
+      if (RESERVED_RENDERER_ATTRIBUTES.has(localName)) {
+        el.removeAttribute(attr.name);
+        continue;
+      }
+      if (EVENT_HANDLER_RE.test(name)) {
+        el.removeAttribute(attr.name);
+        continue;
+      }
+      if (STRICT_URL_ATTRS.has(name) && !attr.value.trim().startsWith("#")) {
+        el.removeAttribute(attr.name);
+        continue;
+      }
+      if (CSS_REF_ATTRS.has(name) && containsUnsafeCssValue(attr.value)) {
+        el.removeAttribute(attr.name);
+        continue;
+      }
+      if (name === "style") {
+        const sanitized = sanitizeCssText(attr.value);
+        if (!sanitized)
+          el.removeAttribute(attr.name);
+        else if (sanitized !== attr.value)
+          el.setAttribute(attr.name, sanitized);
+      }
+    }
+    if (el.localName.toLowerCase() === "style") {
+      const text = el.textContent;
+      if (text) {
+        const sanitized = sanitizeCssText(text);
+        if (sanitized !== text)
+          el.textContent = sanitized;
+      }
+    }
+  }
+}
+function parseSvgData(svgText) {
+  const doc = new DOMParser().parseFromString(svgText, "image/svg+xml");
+  if (doc.getElementsByTagName("parsererror").length > 0) {
+    throw new FacetRenderError("SVG source is not well-formed XML", "svg_malformed");
+  }
+  const root = doc.documentElement;
+  if (root === null || root.localName.toLowerCase() !== "svg") {
+    throw new FacetRenderError("SVG source root element is not <svg>", "svg_bad_root");
+  }
+  if (root.tagName.includes("<") || root.tagName.includes(">")) {
+    throw new FacetRenderError("SVG source is not well-formed XML", "svg_malformed");
+  }
+  return doc;
+}
+async function importSanitizedSvgText(container, svgText, options = {}) {
+  const settleMs = options.settleMs ?? 40;
+  const maxWaitMs = options.maxWaitMs ?? 1500;
+  const doc = parseSvgData(svgText);
+  sanitizeSvgDocument(doc);
+  const imported = document.importNode(doc.documentElement, true);
+  imported.setAttribute(RENDERER_ROOT_ATTRIBUTE, "true");
+  if (options.marker === "graph")
+    imported.setAttribute(RENDERER_GRAPH_ATTRIBUTE, "true");
+  container.appendChild(imported);
+  await new Promise((resolve) => {
+    let quietTimer = null;
+    const cap = setTimeout(() => finish(), maxWaitMs);
+    const observer = new MutationObserver(() => {
+      if (quietTimer !== null)
+        clearTimeout(quietTimer);
+      quietTimer = setTimeout(() => finish(), settleMs);
+    });
+    const finish = () => {
+      observer.disconnect();
+      if (quietTimer !== null)
+        clearTimeout(quietTimer);
+      clearTimeout(cap);
+      resolve();
+    };
+    observer.observe(imported, { childList: true, subtree: true, attributes: true });
+    quietTimer = setTimeout(() => finish(), settleMs);
+  });
+}
+async function renderSvgDocument(ctx, bytes) {
+  const text = decodeArtifactBytes(bytes);
+  await importSanitizedSvgText(ctx.container, text);
+}
+
+export { importSanitizedSvgText, renderSvgDocument };

package/dist/gallery/frame/chunks/mermaid-de7p4v0x.js

@@ -0,0 +1,30 @@
+import {
+  mermaidInitializeConfig,
+  renderMermaidDocument,
+  renderMermaidInto
+} from "./markdown-z1wc0v0d.js";
+import"./markdown-6zz8efx2.js";
+import"./markdown-rm2yxfjj.js";
+import"./markdown-h7pzv34e.js";
+import"./markdown-zazx9h4n.js";
+import"./markdown-d1wfbs70.js";
+import"./markdown-s1jatrnk.js";
+import"./markdown-m7frq8x8.js";
+import"./markdown-tvdpppw8.js";
+import"./markdown-sgfg5vvq.js";
+import"./markdown-82xmzhzd.js";
+import"./markdown-c9k0fvp1.js";
+import"./markdown-qx3cngz2.js";
+import"./markdown-yengsms5.js";
+import"./markdown-ff5wvb43.js";
+import"./markdown-pzgd8z3s.js";
+import"./markdown-92n37gd4.js";
+import"./markdown-xw8dsk8b.js";
+import"./markdown-1s5vwkf2.js";
+import"./markdown-dy5sgjhc.js";
+import"./markdown-809k7q41.js";
+export {
+  mermaidInitializeConfig,
+  renderMermaidDocument,
+  renderMermaidInto
+};