@bendyline/squisq 2.12.1 → 2.12.3

package/dist/chunk-MWSGNEH6.js

@@ -0,0 +1,2376 @@
+import {
+  BUILD_EFFECTS,
+  BUILD_MODES,
+  BUILD_PREVIOUS,
+  SVG_ISLAND_LIMITS,
+  TRANSITION_DIRECTIONS,
+  TRANSITION_TYPES,
+  normalizeTransitionDirection,
+  normalizeTransitionType
+} from "./chunk-P53Z4RYC.js";
+
+// src/markdown/mediaReference.ts
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set(["mp4", "m4v", "mov", "webm", "ogv"]);
+var AUDIO_EXTENSIONS = /* @__PURE__ */ new Set(["mp3", "m4a", "aac", "wav", "ogg", "oga", "opus", "flac"]);
+var CONTAINER_EXTENSIONS = /* @__PURE__ */ new Set(["webm", "mp4"]);
+function mediaKindForUrl(url) {
+  const path = url.split(/[?#]/, 1)[0] ?? "";
+  const name = path.slice(path.lastIndexOf("/") + 1);
+  const dot = name.lastIndexOf(".");
+  if (dot <= 0) return null;
+  const ext = name.slice(dot + 1).toLowerCase();
+  if (AUDIO_EXTENSIONS.has(ext)) return "audio";
+  if (CONTAINER_EXTENSIONS.has(ext) && /^(?:\.\/)?audio\//i.test(path)) return "audio";
+  if (VIDEO_EXTENSIONS.has(ext)) return "video";
+  return null;
+}
+
+// src/markdown/htmlParse.ts
+import { fromHtml } from "hast-util-from-html";
+var HAST_PROP_TO_ATTR = {
+  className: "class",
+  htmlFor: "for",
+  httpEquiv: "http-equiv",
+  acceptCharset: "accept-charset"
+};
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function propertyToAttribute(prop) {
+  if (HAST_PROP_TO_ATTR[prop]) return HAST_PROP_TO_ATTR[prop];
+  if (prop.length > 4 && prop.startsWith("data") && prop[4] >= "A" && prop[4] <= "Z") {
+    return "data-" + prop.slice(4).replace(/[A-Z]/g, (m) => "-" + m.toLowerCase()).replace(/^-/, "");
+  }
+  if (prop.length > 4 && prop.startsWith("aria") && prop[4] >= "A" && prop[4] <= "Z") {
+    return "aria-" + prop.slice(4).replace(/[A-Z]/g, (m) => "-" + m.toLowerCase()).replace(/^-/, "");
+  }
+  return prop.toLowerCase();
+}
+function convertHastProperties(properties) {
+  const attrs = {};
+  for (const [key, value] of Object.entries(properties)) {
+    if (value === false || value === void 0 || value === null) continue;
+    const attrName = propertyToAttribute(key);
+    if (value === true) {
+      attrs[attrName] = "";
+    } else if (Array.isArray(value)) {
+      attrs[attrName] = value.join(" ");
+    } else {
+      attrs[attrName] = String(value);
+    }
+  }
+  return attrs;
+}
+function hastChildrenToNodes(children) {
+  const result = [];
+  for (const child of children) {
+    const node = hastNodeToHtmlNode(child);
+    if (node) result.push(node);
+  }
+  return result;
+}
+function hastNodeToHtmlNode(node) {
+  switch (node.type) {
+    case "element": {
+      const tagName = node.tagName;
+      const properties = node.properties ?? {};
+      const children = node.children ?? [];
+      return {
+        type: "htmlElement",
+        tagName,
+        attributes: convertHastProperties(properties),
+        children: hastChildrenToNodes(children),
+        selfClosing: VOID_ELEMENTS.has(tagName) && children.length === 0
+      };
+    }
+    case "text":
+      return {
+        type: "htmlText",
+        value: node.value
+      };
+    case "comment":
+      return {
+        type: "htmlComment",
+        value: node.value
+      };
+    case "doctype":
+      return null;
+    default:
+      return null;
+  }
+}
+function parseHtmlToNodes(html) {
+  if (!html || !html.trim()) return [];
+  try {
+    const tree = fromHtml(html, { fragment: true });
+    return hastChildrenToNodes(tree.children);
+  } catch {
+    return [{ type: "htmlText", value: html }];
+  }
+}
+function escapeHtmlAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeHtmlText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+var RAW_TEXT_ELEMENTS = /* @__PURE__ */ new Set(["script", "style"]);
+function stringifyNode(node, rawText = false) {
+  switch (node.type) {
+    case "htmlElement": {
+      const attrs = Object.entries(node.attributes).map(([k, v]) => v === "" ? k : `${k}="${escapeHtmlAttr(v)}"`).join(" ");
+      const open = attrs ? `<${node.tagName} ${attrs}>` : `<${node.tagName}>`;
+      if (node.selfClosing) return open;
+      const raw = RAW_TEXT_ELEMENTS.has(node.tagName.toLowerCase());
+      const inner = node.children.map((child) => stringifyNode(child, raw)).join("");
+      return `${open}${inner}</${node.tagName}>`;
+    }
+    case "htmlText":
+      return rawText ? node.value : escapeHtmlText(node.value);
+    case "htmlComment":
+      return `<!--${node.value}-->`;
+  }
+}
+function stringifyHtmlNodes(nodes) {
+  return nodes.map((node) => stringifyNode(node)).join("");
+}
+
+// src/markdown/utils.ts
+function getChildren(node) {
+  if ("children" in node && Array.isArray(node.children)) {
+    return node.children;
+  }
+  return [];
+}
+function walkMarkdownTree(node, visitor, parent) {
+  const skip = visitor(node, parent);
+  if (skip === true) return;
+  const children = getChildren(node);
+  for (const child of children) {
+    walkMarkdownTree(child, visitor, node);
+  }
+}
+function findNodesByType(root, type) {
+  const results = [];
+  walkMarkdownTree(root, (node) => {
+    if (node.type === type) {
+      results.push(node);
+    }
+  });
+  return results;
+}
+function extractPlainText(node) {
+  if ("value" in node && typeof node.value === "string") {
+    return node.value;
+  }
+  const children = getChildren(node);
+  const separator = node.type === "list" || node.type === "listItem" || node.type === "table" ? "\n" : node.type === "tableRow" ? " " : "";
+  return children.map(extractPlainText).join(separator);
+}
+function countNodes(node) {
+  let count = 1;
+  const children = getChildren(node);
+  for (const child of children) {
+    count += countNodes(child);
+  }
+  return count;
+}
+var YAML_TRUE = /* @__PURE__ */ new Set(["true", "True", "TRUE"]);
+var YAML_FALSE = /* @__PURE__ */ new Set(["false", "False", "FALSE"]);
+var YAML_NULL = /* @__PURE__ */ new Set(["null", "Null", "NULL", "~"]);
+var YAML_CANONICAL_NUMBER_RE = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:e[+-][0-9]+)?$/;
+function isCanonicalNumber(text) {
+  return YAML_CANONICAL_NUMBER_RE.test(text) && String(Number(text)) === text;
+}
+function assignKey(map, key, value) {
+  Object.defineProperty(map, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
+function indentOf(line) {
+  return line.length - line.trimStart().length;
+}
+function isSkippableLine(line) {
+  const trimmed = line.trim();
+  return trimmed === "" || trimmed.startsWith("#");
+}
+function nextSignificant(cur) {
+  let j = cur.i;
+  while (j < cur.lines.length && isSkippableLine(cur.lines[j])) j++;
+  return j;
+}
+function isSequenceItem(content) {
+  return content === "-" || content.startsWith("- ");
+}
+function readQuotedScalar(text) {
+  const quote = text[0];
+  if (quote === '"') {
+    for (let i = 1; i < text.length; i++) {
+      if (text[i] === "\\") {
+        i++;
+        continue;
+      }
+      if (text[i] !== '"') continue;
+      const raw = text.slice(0, i + 1);
+      try {
+        return { value: JSON.parse(raw), rest: text.slice(i + 1) };
+      } catch {
+        return { value: raw.slice(1, -1), rest: text.slice(i + 1) };
+      }
+    }
+    return null;
+  }
+  if (quote === "'") {
+    let value = "";
+    for (let i = 1; i < text.length; i++) {
+      if (text[i] !== "'") {
+        value += text[i];
+        continue;
+      }
+      if (text[i + 1] === "'") {
+        value += "'";
+        i++;
+        continue;
+      }
+      return { value, rest: text.slice(i + 1) };
+    }
+    return null;
+  }
+  return null;
+}
+function splitMappingKey(content) {
+  if (content.startsWith("{") || content.startsWith("[")) return null;
+  if (content.startsWith('"') || content.startsWith("'")) {
+    const quoted = readQuotedScalar(content);
+    if (!quoted) return null;
+    const after = quoted.rest;
+    if (after === ":" || after.startsWith(": ") || after.startsWith(":	")) {
+      return { key: quoted.value, rest: after.slice(1).trim() };
+    }
+    return null;
+  }
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] !== ":") continue;
+    const next = content[i + 1];
+    if (next !== void 0 && next !== " " && next !== "	") continue;
+    const key = content.slice(0, i).trim();
+    if (!key) return null;
+    return { key, rest: content.slice(i + 1).trim() };
+  }
+  const colon = content.indexOf(":");
+  if (colon > 0 && content[colon + 1] !== "/") {
+    const key = content.slice(0, colon).trim();
+    if (key && !key.includes(" ")) return { key, rest: content.slice(colon + 1).trim() };
+  }
+  return null;
+}
+function foldBlockLines(lines) {
+  const parts = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line === "") {
+      parts.push("\n");
+      i++;
+      continue;
+    }
+    if (/^\s/.test(line)) {
+      parts.push((parts.length > 0 ? "\n" : "") + line);
+      i++;
+      continue;
+    }
+    parts.push(line);
+    i++;
+    while (i < lines.length && lines[i] !== "" && !/^\s/.test(lines[i])) {
+      parts.push(` ${lines[i]}`);
+      i++;
+    }
+  }
+  return parts.join("");
+}
+function parseBlockScalar(cur, keyIndent, folded, chomp) {
+  const blockLines = [];
+  let j = cur.i;
+  for (; j < cur.lines.length; j++) {
+    const line = cur.lines[j];
+    if (line.trim() === "") {
+      blockLines.push("");
+      continue;
+    }
+    if (indentOf(line) <= keyIndent) break;
+    blockLines.push(line);
+  }
+  cur.i = j;
+  if (chomp !== "+") {
+    while (blockLines.length > 0 && blockLines[blockLines.length - 1] === "") blockLines.pop();
+  }
+  let commonIndent = Infinity;
+  for (const line of blockLines) {
+    if (line === "") continue;
+    commonIndent = Math.min(commonIndent, indentOf(line));
+  }
+  if (!isFinite(commonIndent)) commonIndent = 0;
+  const dedented = blockLines.map((line) => line === "" ? "" : line.slice(commonIndent));
+  return folded ? foldBlockLines(dedented) : dedented.join("\n");
+}
+function scalarFromText(text) {
+  if (text === "" || YAML_NULL.has(text)) return null;
+  if (YAML_TRUE.has(text)) return true;
+  if (YAML_FALSE.has(text)) return false;
+  if (isCanonicalNumber(text)) return Number(text);
+  return text;
+}
+function collectPlainContinuation(cur, keyIndent, first) {
+  const parts = [first];
+  while (cur.i < cur.lines.length) {
+    const line = cur.lines[cur.i];
+    if (isSkippableLine(line)) break;
+    if (indentOf(line) <= keyIndent) break;
+    parts.push(line.trim());
+    cur.i++;
+  }
+  return parts.join(" ");
+}
+function parseValue(cur, keyIndent, inline) {
+  const blockScalar = /^([|>])([0-9]*)([+-]?)$/.exec(inline);
+  if (blockScalar) {
+    return parseBlockScalar(cur, keyIndent, blockScalar[1] === ">", blockScalar[3]);
+  }
+  if (inline === "") return parseNodeBelowKey(cur, keyIndent);
+  if (inline.startsWith('"') || inline.startsWith("'")) {
+    const quoted = readQuotedScalar(inline);
+    if (quoted && quoted.rest.trim() === "") return quoted.value;
+    const quote = inline[0];
+    if (inline.length >= 2 && inline.endsWith(quote)) {
+      const body = inline.slice(1, -1);
+      return quote === "'" ? body.replace(/''/g, "'") : body;
+    }
+    return inline;
+  }
+  if (inline === "[]") return [];
+  if (inline === "{}") return {};
+  if (inline.startsWith("{") || inline.startsWith("[")) return inline;
+  return scalarFromText(collectPlainContinuation(cur, keyIndent, inline));
+}
+function parseNodeBelowKey(cur, keyIndent) {
+  const j = nextSignificant(cur);
+  if (j >= cur.lines.length) return null;
+  const line = cur.lines[j];
+  const ind = indentOf(line);
+  const content = line.slice(ind);
+  if (isSequenceItem(content) && ind >= keyIndent) {
+    cur.i = j;
+    return parseSequence(cur, ind);
+  }
+  if (ind > keyIndent) {
+    cur.i = j;
+    if (splitMappingKey(content)) return parseMapping(cur, ind);
+    cur.i = j + 1;
+    return scalarFromText(collectPlainContinuation(cur, keyIndent, content.trim()));
+  }
+  return null;
+}
+function parseNodeBelowDash(cur, dashIndent) {
+  const j = nextSignificant(cur);
+  if (j >= cur.lines.length) return null;
+  const line = cur.lines[j];
+  const ind = indentOf(line);
+  if (ind <= dashIndent) return null;
+  const content = line.slice(ind);
+  cur.i = j;
+  if (isSequenceItem(content)) return parseSequence(cur, ind);
+  if (splitMappingKey(content)) return parseMapping(cur, ind);
+  cur.i = j + 1;
+  return scalarFromText(collectPlainContinuation(cur, dashIndent, content.trim()));
+}
+function parseSequence(cur, indent) {
+  const items = [];
+  for (; ; ) {
+    const j = nextSignificant(cur);
+    if (j >= cur.lines.length) {
+      cur.i = j;
+      break;
+    }
+    const line = cur.lines[j];
+    const ind = indentOf(line);
+    if (ind !== indent) break;
+    const content = line.slice(ind);
+    if (!isSequenceItem(content)) break;
+    const afterDash = content.slice(1);
+    const itemText = afterDash.trimStart();
+    if (itemText === "") {
+      cur.i = j + 1;
+      items.push(parseNodeBelowDash(cur, ind));
+      continue;
+    }
+    const itemCol = ind + 1 + (afterDash.length - itemText.length);
+    const entry = splitMappingKey(itemText);
+    if (entry) {
+      cur.lines[j] = " ".repeat(itemCol) + itemText;
+      cur.i = j;
+      items.push(parseMapping(cur, itemCol));
+      continue;
+    }
+    cur.i = j + 1;
+    items.push(parseValue(cur, ind, itemText));
+  }
+  return items;
+}
+function parseMapping(cur, indent) {
+  const map = {};
+  for (; ; ) {
+    const j = nextSignificant(cur);
+    if (j >= cur.lines.length) {
+      cur.i = j;
+      break;
+    }
+    const line = cur.lines[j];
+    const ind = indentOf(line);
+    if (ind !== indent) break;
+    const content = line.slice(ind);
+    if (isSequenceItem(content)) break;
+    const entry = splitMappingKey(content);
+    if (!entry) break;
+    cur.i = j + 1;
+    assignKey(map, entry.key, parseValue(cur, indent, entry.rest));
+  }
+  return map;
+}
+function parseFrontmatter(yaml) {
+  if (!yaml || !yaml.trim()) return null;
+  const cur = { lines: yaml.replace(/\r\n?/g, "\n").split("\n"), i: 0 };
+  const result = {};
+  for (; ; ) {
+    const j = nextSignificant(cur);
+    if (j >= cur.lines.length) break;
+    cur.i = j;
+    const map = parseMapping(cur, indentOf(cur.lines[j]));
+    for (const [key, value] of Object.entries(map)) assignKey(result, key, value);
+    if (cur.i <= j) cur.i = j + 1;
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function formatBlockScalar(value) {
+  const body = value.split("\n").map((line) => line === "" ? "" : `  ${line}`).join("\n");
+  return `|-
+${body}`;
+}
+var FRONTMATTER_BLOCK_RE = /^---\r?\n([\s\S]*?)\r?\n---(\r?\n)?/;
+var EMPTY_FRONTMATTER_BLOCK_RE = /^---\r?\n---(\r?\n)?/;
+function splitFrontmatterBlock(source) {
+  const match = FRONTMATTER_BLOCK_RE.exec(source) ?? EMPTY_FRONTMATTER_BLOCK_RE.exec(source);
+  if (!match) return { frontmatter: null, body: source };
+  return { frontmatter: match[0], body: source.slice(match[0].length) };
+}
+function formatFrontmatterValue(value) {
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (/[\r\n]/.test(value)) return formatBlockScalar(value.replace(/\r\n?/g, "\n"));
+  if (value !== "[]" && value !== "{}" && /^[{[]/.test(value)) return value;
+  const needsQuote = /^\s|\s$/.test(value) || /^[!&*?|>%@`~]/.test(value) || /[:#]/.test(value) || value === "" || value === "[]" || value === "{}" || YAML_TRUE.has(value) || YAML_FALSE.has(value) || YAML_NULL.has(value) || value !== "" && !Number.isNaN(Number(value)) || /^["']/.test(value) && /["']$/.test(value);
+  if (!needsQuote) return value;
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+function formatFrontmatterKey(key) {
+  return /^[A-Za-z0-9_](?:[A-Za-z0-9 _.-]*[A-Za-z0-9_.-])?$/.test(key) ? key : formatFrontmatterValue(key);
+}
+function isPlainRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isOmittedValue(value) {
+  return value === void 0 || typeof value === "function" || typeof value === "symbol";
+}
+function toScalar(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (value instanceof Date) return value.toISOString();
+  return String(value);
+}
+function pushScalar(out, pad, prefix, value) {
+  const formatted = formatFrontmatterValue(toScalar(value));
+  if (!formatted.includes("\n")) {
+    out.push(`${pad}${prefix}${formatted}`);
+    return;
+  }
+  const [head, ...body] = formatted.split("\n");
+  out.push(`${pad}${prefix}${head}`);
+  for (const line of body) out.push(line === "" ? "" : `${pad}${line}`);
+}
+function emitSequence(items, indent, out) {
+  const pad = " ".repeat(indent);
+  for (const item of items) {
+    if (item === null || isOmittedValue(item)) {
+      out.push(`${pad}- null`);
+      continue;
+    }
+    if (Array.isArray(item)) {
+      if (item.length === 0) {
+        out.push(`${pad}- []`);
+        continue;
+      }
+      out.push(`${pad}-`);
+      emitSequence(item, indent + 2, out);
+      continue;
+    }
+    if (isPlainRecord(item)) {
+      const sub = [];
+      emitMapping(item, indent + 2, sub);
+      if (sub.length === 0) {
+        out.push(`${pad}- {}`);
+        continue;
+      }
+      sub[0] = `${pad}- ${sub[0].slice(indent + 2)}`;
+      out.push(...sub);
+      continue;
+    }
+    pushScalar(out, pad, "- ", item);
+  }
+}
+function emitMapping(map, indent, out) {
+  const pad = " ".repeat(indent);
+  for (const [rawKey, value] of Object.entries(map)) {
+    if (isOmittedValue(value)) continue;
+    const key = formatFrontmatterKey(rawKey);
+    if (value === null) {
+      out.push(`${pad}${key}: null`);
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        out.push(`${pad}${key}: []`);
+        continue;
+      }
+      out.push(`${pad}${key}:`);
+      emitSequence(value, indent + 2, out);
+      continue;
+    }
+    if (isPlainRecord(value)) {
+      const sub = [];
+      emitMapping(value, indent + 2, sub);
+      if (sub.length === 0) {
+        out.push(`${pad}${key}: {}`);
+        continue;
+      }
+      out.push(`${pad}${key}:`);
+      out.push(...sub);
+      continue;
+    }
+    pushScalar(out, pad, `${key}: `, value);
+  }
+}
+function formatFrontmatterYaml(frontmatter) {
+  const out = [];
+  emitMapping(frontmatter, 0, out);
+  return out.join("\n");
+}
+function setFrontmatterValues(source, updates) {
+  const updateKeys = Object.keys(updates);
+  if (updateKeys.length === 0) return source;
+  const match = source.match(FRONTMATTER_BLOCK_RE);
+  const handled = /* @__PURE__ */ new Set();
+  if (match) {
+    const inner = match[1];
+    const lines = inner.split(/\r?\n/);
+    const newLines = [];
+    const firstSignificant = lines.find((line) => !isSkippableLine(line));
+    const rootIndent = firstSignificant === void 0 ? 0 : indentOf(firstSignificant);
+    let i = 0;
+    while (i < lines.length) {
+      const line = lines[i];
+      const ind = indentOf(line);
+      const entry = isSkippableLine(line) || ind !== rootIndent ? null : splitMappingKey(line.slice(ind));
+      if (!entry) {
+        newLines.push(line);
+        i++;
+        continue;
+      }
+      let end = i + 1;
+      while (end < lines.length) {
+        if (lines[end].trim() === "") {
+          let probe = end;
+          while (probe < lines.length && lines[probe].trim() === "") probe++;
+          if (probe < lines.length && indentOf(lines[probe]) > rootIndent) {
+            end = probe;
+            continue;
+          }
+          break;
+        }
+        if (indentOf(lines[end]) <= rootIndent) break;
+        end++;
+      }
+      if (!Object.prototype.hasOwnProperty.call(updates, entry.key)) {
+        for (let k = i; k < end; k++) newLines.push(lines[k]);
+        i = end;
+        continue;
+      }
+      handled.add(entry.key);
+      const next = updates[entry.key];
+      if (next !== null && next !== void 0) {
+        pushScalar(newLines, " ".repeat(rootIndent), `${formatFrontmatterKey(entry.key)}: `, next);
+      }
+      i = end;
+    }
+    for (const key of updateKeys) {
+      if (handled.has(key)) continue;
+      const next = updates[key];
+      if (next === null || next === void 0) continue;
+      pushScalar(newLines, "", `${formatFrontmatterKey(key)}: `, next);
+    }
+    const nonEmpty = newLines.filter((l) => l.trim().length > 0);
+    const rest = source.slice(match[0].length);
+    if (nonEmpty.length === 0) return rest;
+    return `---
+${newLines.join("\n")}
+---
+${rest}`;
+  }
+  const fresh = [];
+  for (const key of updateKeys) {
+    const next = updates[key];
+    if (next === null || next === void 0) continue;
+    pushScalar(fresh, "", `${formatFrontmatterKey(key)}: `, next);
+  }
+  if (fresh.length === 0) return source;
+  return `---
+${fresh.join("\n")}
+---
+${source}`;
+}
+function createDocument(...children) {
+  return {
+    type: "document",
+    children
+  };
+}
+function inferDocumentTitle(doc) {
+  const fmTitle = doc.frontmatter?.title;
+  if (typeof fmTitle === "string") {
+    const trimmed = fmTitle.trim();
+    if (trimmed) return trimmed;
+  }
+  let best = null;
+  for (const node of doc.children) {
+    if (node.type !== "heading") continue;
+    const text = extractPlainText(node).trim();
+    if (!text) continue;
+    if (best === null || node.depth < best.depth) {
+      best = { depth: node.depth, text };
+      if (best.depth === 1) break;
+    }
+  }
+  return best?.text;
+}
+function readFrontmatterThemeId(frontmatter) {
+  if (!frontmatter) return void 0;
+  const keys = ["squisq-theme", "themeId", "theme"];
+  for (const key of keys) {
+    const raw = frontmatter[key];
+    if (typeof raw === "string") {
+      const trimmed = raw.trim();
+      if (trimmed) return trimmed;
+    }
+  }
+  return void 0;
+}
+function plainTextFromInlineHtml(html) {
+  const BLOCK = /* @__PURE__ */ new Set([
+    "p",
+    "div",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "li",
+    "blockquote",
+    "pre"
+  ]);
+  const walk = (nodes) => nodes.map((n) => {
+    if (n.type === "htmlText") return n.value;
+    if (n.type !== "htmlElement") return "";
+    const tag = n.tagName.toLowerCase();
+    if (tag === "br") return "\n";
+    const inner = walk(n.children);
+    return BLOCK.has(tag) ? `${inner}
+` : inner;
+  }).join("");
+  return walk(parseHtmlToNodes(html)).replace(/\u00A0/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+// src/markdown/annotationCoercion.ts
+var KNOWN_BLOCK_META_KEYS = {
+  build: "build",
+  buildEffect: "buildEffect",
+  buildDuration: "time",
+  buildPrevious: "buildPrevious",
+  x: "number",
+  y: "number",
+  startTime: "time",
+  duration: "time",
+  connectsTo: "connectionList",
+  transition: "transition",
+  transitionDuration: "time",
+  transitionDirection: "transitionDirection"
+};
+var BLOCK_META_KEY_DESCRIPTORS = [
+  { key: "build", description: "Progressive reveal grouping", values: BUILD_MODES },
+  { key: "buildEffect", description: "Build entrance effect", values: BUILD_EFFECTS },
+  {
+    key: "buildDuration",
+    description: "Build entrance duration",
+    valueHint: "seconds \u2014 e.g. 0.4, 400ms"
+  },
+  {
+    key: "buildPrevious",
+    description: "Appearance of previous build steps",
+    values: BUILD_PREVIOUS
+  },
+  {
+    key: "transition",
+    description: "Block-to-block transition effect",
+    values: TRANSITION_TYPES
+  },
+  {
+    key: "transitionDuration",
+    description: "How long the transition lasts",
+    valueHint: "seconds \u2014 e.g. 0.7, 700ms"
+  },
+  {
+    key: "transitionDirection",
+    description: "Directional variant for the transition",
+    values: TRANSITION_DIRECTIONS
+  },
+  {
+    key: "startTime",
+    description: "Timeline start time of this block",
+    valueHint: "mm:ss or seconds \u2014 e.g. 01:30, 5, 1500ms"
+  },
+  {
+    key: "duration",
+    description: "How long this block lasts",
+    valueHint: "mm:ss or seconds \u2014 e.g. 45, 1500ms"
+  },
+  {
+    key: "x",
+    description: "Horizontal position on the diagram canvas",
+    valueHint: "number \u2014 e.g. 600"
+  },
+  {
+    key: "y",
+    description: "Vertical position on the diagram canvas",
+    valueHint: "number \u2014 e.g. 300"
+  },
+  {
+    key: "connectsTo",
+    description: "Diagram connections to other blocks",
+    valueHint: "comma-separated target or target:type \u2014 e.g. foo,bar:flow"
+  }
+];
+function coerceAnnotationValues(params) {
+  const blockMeta = {};
+  const metadata = {};
+  const warnings = [];
+  const build2 = {};
+  let transitionType = null;
+  let transitionDuration;
+  let transitionDirection;
+  for (const [key, raw] of Object.entries(params)) {
+    const kind = KNOWN_BLOCK_META_KEYS[key];
+    if (!kind) {
+      metadata[key] = raw;
+      continue;
+    }
+    if (kind === "number") {
+      const n = parseNumber(raw);
+      if (n == null) {
+        warnings.push(`Invalid number for "${key}": ${JSON.stringify(raw)}`);
+      } else {
+        blockMeta[key] = n;
+      }
+    } else if (kind === "time") {
+      const s = parseTimeSeconds(raw);
+      if (s == null) {
+        warnings.push(`Invalid time for "${key}": ${JSON.stringify(raw)}`);
+      } else if (key === "buildDuration") {
+        if (s < 0) warnings.push("Build duration must be non-negative.");
+        else build2.duration = s;
+      } else if (key === "transitionDuration") {
+        transitionDuration = s;
+      } else {
+        blockMeta[key] = s;
+      }
+    } else if (kind === "build" || kind === "buildEffect" || kind === "buildPrevious") {
+      const values = kind === "build" ? BUILD_MODES : kind === "buildEffect" ? BUILD_EFFECTS : BUILD_PREVIOUS;
+      if (!values.includes(raw))
+        warnings.push(`Invalid value for "${key}": ${JSON.stringify(raw)}`);
+      else if (kind === "build") build2.mode = raw;
+      else if (kind === "buildEffect") build2.effect = raw;
+      else build2.previous = raw;
+    } else if (kind === "connectionList") {
+      const { list, warning } = parseConnectionList(raw);
+      if (warning) warnings.push(`"${key}": ${warning}`);
+      blockMeta.connectsTo = list;
+    } else if (kind === "transition") {
+      const transition = normalizeTransitionType(raw);
+      if (transition == null) {
+        warnings.push(`Invalid transition for "${key}": ${JSON.stringify(raw)}`);
+      } else {
+        transitionType = transition;
+      }
+    } else if (kind === "transitionDirection") {
+      const direction = normalizeTransitionDirection(raw);
+      if (direction == null) {
+        warnings.push(`Invalid transition direction for "${key}": ${JSON.stringify(raw)}`);
+      } else {
+        transitionDirection = direction;
+      }
+    }
+  }
+  if (build2.mode) blockMeta.build = { ...build2, mode: build2.mode };
+  if (transitionType) {
+    blockMeta.transition = {
+      type: transitionType,
+      ...transitionDuration !== void 0 ? { duration: transitionDuration } : {},
+      ...transitionDirection !== void 0 ? { direction: transitionDirection } : {}
+    };
+  }
+  return { blockMeta, metadata, warnings };
+}
+function parseNumber(raw) {
+  if (raw.trim() === "") return null;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : null;
+}
+var TIME_BARE_RE = /^\d+(?:\.\d+)?$/;
+var TIME_MS_RE = /^(\d+(?:\.\d+)?)ms$/;
+var TIME_MMSS_RE = /^(\d+):(\d{1,2})(?:\.(\d+))?$/;
+function parseTimeSeconds(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (TIME_BARE_RE.test(trimmed)) {
+    const n = Number(trimmed);
+    return Number.isFinite(n) ? n : null;
+  }
+  const msMatch = trimmed.match(TIME_MS_RE);
+  if (msMatch) {
+    const n = Number(msMatch[1]);
+    return Number.isFinite(n) ? n / 1e3 : null;
+  }
+  const mmssMatch = trimmed.match(TIME_MMSS_RE);
+  if (mmssMatch) {
+    const mins = Number(mmssMatch[1]);
+    const secs = Number(mmssMatch[2]);
+    const frac = mmssMatch[3] ? Number(`0.${mmssMatch[3]}`) : 0;
+    if (!Number.isFinite(mins) || !Number.isFinite(secs) || !Number.isFinite(frac)) {
+      return null;
+    }
+    if (secs >= 60) return null;
+    return mins * 60 + secs + frac;
+  }
+  return null;
+}
+function parseConnectionList(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return { list: [], warning: null };
+  const list = [];
+  let droppedEmpty = false;
+  for (const part of trimmed.split(",")) {
+    const entry = part.trim();
+    if (!entry) {
+      droppedEmpty = true;
+      continue;
+    }
+    const colonIdx = entry.indexOf(":");
+    if (colonIdx < 0) {
+      list.push({ target: entry });
+    } else {
+      const target = entry.slice(0, colonIdx).trim();
+      const type = entry.slice(colonIdx + 1).trim();
+      if (!target) {
+        droppedEmpty = true;
+        continue;
+      }
+      list.push(type ? { target, type } : { target });
+    }
+  }
+  return {
+    list,
+    warning: droppedEmpty ? "dropped empty connection entries" : null
+  };
+}
+
+// src/markdown/videoEmbed.ts
+var VIDEO_EMBED_PROVIDERS = [
+  { id: "youtube", name: "YouTube", example: "https://www.youtube.com/watch?v=dQw4w9WgXcQ" },
+  { id: "vimeo", name: "Vimeo", example: "https://vimeo.com/76979871" },
+  {
+    id: "loom",
+    name: "Loom",
+    example: "https://www.loom.com/share/0281766fa2d04bb788eaf19e65135184"
+  },
+  { id: "dailymotion", name: "Dailymotion", example: "https://www.dailymotion.com/video/x7tgad0" },
+  { id: "wistia", name: "Wistia", example: "https://home.wistia.com/medias/e4a27b971d" }
+];
+var PROVIDER_NAMES = Object.fromEntries(
+  VIDEO_EMBED_PROVIDERS.map((p) => [p.id, p.name])
+);
+var LANDSCAPE = 16 / 9;
+var PORTRAIT = 9 / 16;
+function unescapeMarkdown(value) {
+  return value.replace(/\\([!-/:-@[-`{-~])/g, "$1");
+}
+function toUrl(input) {
+  let text = unescapeMarkdown(input.trim());
+  if (text.startsWith("<") && text.endsWith(">")) text = text.slice(1, -1).trim();
+  if (!text || /\s/.test(text)) return null;
+  if (text.startsWith("//")) text = `https:${text}`;
+  else if (!/^[a-z][a-z0-9+.-]*:/i.test(text)) text = `https://${text}`;
+  let url;
+  try {
+    url = new URL(text);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+  if (url.username || url.password || url.port) return null;
+  return url;
+}
+function baseHost(url) {
+  return url.hostname.toLowerCase().replace(/^(?:www|m)\./, "");
+}
+function pathSegments(url) {
+  return url.pathname.split("/").filter(Boolean).map((segment) => {
+    try {
+      return decodeURIComponent(segment);
+    } catch {
+      return segment;
+    }
+  });
+}
+function fragmentParam(url, key) {
+  const hash = url.hash.replace(/^#/, "");
+  if (!hash) return null;
+  return new URLSearchParams(hash).get(key);
+}
+var HMS_RE = /^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s?)?$/;
+var CLOCK_RE = /^(?:(\d+):)?(\d{1,2}):(\d{2})$/;
+function parseVideoStartTime(raw) {
+  if (!raw) return void 0;
+  const value = raw.trim().toLowerCase();
+  if (!value) return void 0;
+  let total = null;
+  const hms = HMS_RE.exec(value);
+  if (hms && (hms[1] || hms[2] || hms[3])) {
+    total = Number(hms[1] ?? 0) * 3600 + Number(hms[2] ?? 0) * 60 + Number(hms[3] ?? 0);
+  } else {
+    const clock = CLOCK_RE.exec(value);
+    const minutes = Number(clock?.[2]);
+    const seconds = Number(clock?.[3]);
+    if (clock && seconds < 60 && (clock[1] === void 0 || minutes < 60)) {
+      total = Number(clock[1] ?? 0) * 3600 + minutes * 60 + seconds;
+    }
+  }
+  if (total === null || !Number.isFinite(total) || total <= 0) return void 0;
+  return Math.floor(total);
+}
+function withQuery(base, params) {
+  const query = params.filter((entry) => entry[1] !== void 0).map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&");
+  return query ? `${base}?${query}` : base;
+}
+function build(provider, fields) {
+  const embed = {
+    provider,
+    providerName: PROVIDER_NAMES[provider],
+    id: fields.id,
+    embedUrl: fields.embedUrl,
+    watchUrl: fields.watchUrl,
+    aspectRatio: fields.aspectRatio ?? LANDSCAPE
+  };
+  if (fields.playlistId) embed.playlistId = fields.playlistId;
+  if (fields.startSeconds) embed.startSeconds = fields.startSeconds;
+  if (fields.thumbnailUrl) embed.thumbnailUrl = fields.thumbnailUrl;
+  return embed;
+}
+var YOUTUBE_HOSTS = /* @__PURE__ */ new Set(["youtube.com", "music.youtube.com", "youtube-nocookie.com"]);
+var YOUTUBE_ID_RE = /^[A-Za-z0-9_-]{11}$/;
+var YOUTUBE_LIST_RE = /^[A-Za-z0-9_-]{2,80}$/;
+var YOUTUBE_ID_PATHS = /* @__PURE__ */ new Set(["embed", "v", "e", "live", "shorts"]);
+var YOUTUBE_EMBED_ORIGIN = "https://www.youtube-nocookie.com";
+function parseYouTube(url) {
+  const host = baseHost(url);
+  const segments = pathSegments(url);
+  const params = url.searchParams;
+  let id = null;
+  let shorts = false;
+  if (host === "youtu.be") {
+    id = segments[0] ?? null;
+  } else if (YOUTUBE_HOSTS.has(host)) {
+    const [head, second] = segments;
+    if (head === "watch") id = params.get("v");
+    else if (head && YOUTUBE_ID_PATHS.has(head) && second !== "videoseries") {
+      id = second ?? null;
+      shorts = head === "shorts";
+    } else if (head !== "playlist" && !(head === "embed" && second === "videoseries")) {
+      return null;
+    }
+  } else {
+    return null;
+  }
+  if (id !== null && !YOUTUBE_ID_RE.test(id)) return null;
+  const list = params.get("list");
+  const playlistId = list && YOUTUBE_LIST_RE.test(list) ? list : void 0;
+  if (!id && !playlistId) return null;
+  const startSeconds = parseVideoStartTime(
+    params.get("t") ?? params.get("start") ?? fragmentParam(url, "t")
+  );
+  const start = startSeconds ? String(startSeconds) : void 0;
+  if (!id) {
+    return build("youtube", {
+      id: playlistId,
+      playlistId,
+      embedUrl: withQuery(`${YOUTUBE_EMBED_ORIGIN}/embed/videoseries`, [["list", playlistId]]),
+      watchUrl: withQuery("https://www.youtube.com/playlist", [["list", playlistId]])
+    });
+  }
+  return build("youtube", {
+    id,
+    playlistId,
+    startSeconds,
+    embedUrl: withQuery(`${YOUTUBE_EMBED_ORIGIN}/embed/${id}`, [
+      ["list", playlistId],
+      ["start", start]
+    ]),
+    watchUrl: shorts ? `https://www.youtube.com/shorts/${id}` : withQuery("https://www.youtube.com/watch", [
+      ["v", id],
+      ["list", playlistId],
+      ["t", start && `${start}s`]
+    ]),
+    thumbnailUrl: `https://i.ytimg.com/vi/${id}/hqdefault.jpg`,
+    aspectRatio: shorts ? PORTRAIT : LANDSCAPE
+  });
+}
+var VIMEO_ID_RE = /^\d{1,12}$/;
+var VIMEO_HASH_RE = /^[0-9a-f]{6,24}$/i;
+function vimeoIdFromSegments(segments) {
+  const [a, b, c, d] = segments;
+  if (a && VIMEO_ID_RE.test(a)) {
+    return { id: a, ...b && VIMEO_HASH_RE.test(b) ? { hash: b } : {} };
+  }
+  if (a === "video" && b && VIMEO_ID_RE.test(b)) return { id: b };
+  if (a === "channels" && c && VIMEO_ID_RE.test(c)) return { id: c };
+  if (a === "groups" && c === "videos" && d && VIMEO_ID_RE.test(d)) return { id: d };
+  if ((a === "album" || a === "showcase") && c === "video" && d && VIMEO_ID_RE.test(d)) {
+    return { id: d };
+  }
+  return null;
+}
+function parseVimeo(url) {
+  const host = baseHost(url);
+  if (host !== "vimeo.com" && host !== "player.vimeo.com") return null;
+  const found = vimeoIdFromSegments(pathSegments(url));
+  if (!found) return null;
+  const queryHash = url.searchParams.get("h");
+  const hash = found.hash ?? (queryHash && VIMEO_HASH_RE.test(queryHash) ? queryHash : void 0);
+  const startSeconds = parseVideoStartTime(
+    fragmentParam(url, "t") ?? url.searchParams.get("t") ?? url.searchParams.get("start")
+  );
+  const timeFragment = startSeconds ? `#t=${startSeconds}s` : "";
+  return build("vimeo", {
+    id: found.id,
+    startSeconds,
+    embedUrl: withQuery(`https://player.vimeo.com/video/${found.id}`, [["h", hash]]) + timeFragment,
+    watchUrl: `https://vimeo.com/${found.id}${hash ? `/${hash}` : ""}${timeFragment}`
+  });
+}
+var LOOM_ID_RE = /(?:^|-)([0-9a-f]{32})$/i;
+function parseLoom(url) {
+  if (baseHost(url) !== "loom.com") return null;
+  const [head, second] = pathSegments(url);
+  if (head !== "share" && head !== "embed" || !second) return null;
+  const match = LOOM_ID_RE.exec(second);
+  if (!match) return null;
+  const id = match[1].toLowerCase();
+  return build("loom", {
+    id,
+    embedUrl: `https://www.loom.com/embed/${id}`,
+    watchUrl: `https://www.loom.com/share/${id}`
+  });
+}
+var DAILYMOTION_ID_RE = /^[A-Za-z0-9]{5,20}$/;
+function parseDailymotion(url) {
+  const host = baseHost(url);
+  const segments = pathSegments(url);
+  let raw = null;
+  if (host === "dai.ly") raw = segments[0] ?? null;
+  else if (host === "dailymotion.com") {
+    if (segments[0] === "video") raw = segments[1] ?? null;
+    else if (segments[0] === "embed" && segments[1] === "video") raw = segments[2] ?? null;
+    else return null;
+  } else if (host === "geo.dailymotion.com") {
+    raw = url.searchParams.get("video");
+  } else {
+    return null;
+  }
+  const id = raw?.split("_")[0];
+  if (!id || !DAILYMOTION_ID_RE.test(id)) return null;
+  const startSeconds = parseVideoStartTime(url.searchParams.get("start"));
+  const start = startSeconds ? String(startSeconds) : void 0;
+  return build("dailymotion", {
+    id,
+    startSeconds,
+    embedUrl: withQuery(`https://www.dailymotion.com/embed/video/${id}`, [["start", start]]),
+    watchUrl: withQuery(`https://www.dailymotion.com/video/${id}`, [["start", start]]),
+    thumbnailUrl: `https://www.dailymotion.com/thumbnail/video/${id}`
+  });
+}
+var WISTIA_ID_RE = /^[a-z0-9]{10}$/;
+var WISTIA_ACCOUNT_HOST_RE = /^[a-z0-9-]{1,63}\.wistia\.com$/;
+function parseWistia(url) {
+  const host = url.hostname.toLowerCase();
+  const fastHost = host === "fast.wistia.net" || host === "fast.wistia.com";
+  if (!fastHost && !WISTIA_ACCOUNT_HOST_RE.test(host)) return null;
+  const segments = pathSegments(url);
+  let raw;
+  if (segments[0] === "medias") raw = segments[1];
+  else if (segments[0] === "embed" && (segments[1] === "iframe" || segments[1] === "medias")) {
+    raw = segments[2];
+  }
+  const id = raw?.replace(/\.jsonp$/, "");
+  if (!id || !WISTIA_ID_RE.test(id)) return null;
+  const embedUrl = `https://fast.wistia.net/embed/iframe/${id}`;
+  return build("wistia", {
+    id,
+    embedUrl,
+    // A media page lives on the account's own subdomain; the fast host only
+    // serves the player, which doubles as a viewable page.
+    watchUrl: fastHost ? embedUrl : `https://${host}/medias/${id}`
+  });
+}
+var PARSERS = [
+  parseYouTube,
+  parseVimeo,
+  parseLoom,
+  parseDailymotion,
+  parseWistia
+];
+function parseVideoEmbedUrl(input) {
+  if (typeof input !== "string") return null;
+  const url = toUrl(input);
+  if (!url) return null;
+  for (const parse of PARSERS) {
+    const embed = parse(url);
+    if (embed) return embed;
+  }
+  return null;
+}
+function isVideoEmbedUrl(input) {
+  return parseVideoEmbedUrl(input) !== null;
+}
+var VIDEO_EMBED_IFRAME_ALLOW = "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share; fullscreen";
+function videoEmbedIframeAttributes(embed, title) {
+  return {
+    src: embed.embedUrl,
+    title: title?.trim() || `${embed.providerName} video`,
+    allow: VIDEO_EMBED_IFRAME_ALLOW,
+    allowfullscreen: "",
+    referrerpolicy: "strict-origin-when-cross-origin",
+    loading: "lazy"
+  };
+}
+var GENERIC_PLAYER_TITLE_RE = /^(?:[\w .-]+[ -])?(?:video[ -])?player$/i;
+function attributeOf(element, name) {
+  for (const [key, value] of Object.entries(element.attributes)) {
+    if (key.toLowerCase() === name) return value;
+  }
+  return void 0;
+}
+function soleIframe(nodes) {
+  let found = null;
+  let disqualified = false;
+  const visit = (list) => {
+    for (const node of list) {
+      if (disqualified) return;
+      if (node.type === "htmlText") {
+        if (node.value.trim()) disqualified = true;
+        continue;
+      }
+      if (node.type !== "htmlElement") continue;
+      const tag = node.tagName.toLowerCase();
+      if (tag === "iframe") {
+        if (found) disqualified = true;
+        found = node;
+        continue;
+      }
+      if (tag === "script" || tag === "style" || tag === "noscript") continue;
+      visit(node.children);
+    }
+  };
+  visit(nodes);
+  return disqualified ? null : found;
+}
+function iframeEmbed(element) {
+  const embed = parseVideoEmbedUrl(attributeOf(element, "src"));
+  if (!embed) return null;
+  const title = attributeOf(element, "title")?.trim() ?? "";
+  const generic = GENERIC_PLAYER_TITLE_RE.test(title) || title.toLowerCase() === `${embed.providerName} video`.toLowerCase();
+  return { embed, title: title && !generic ? title : null };
+}
+function videoEmbedFromIframe(element) {
+  return element.tagName.toLowerCase() === "iframe" ? iframeEmbed(element) : null;
+}
+function parseVideoEmbedInput(input) {
+  if (typeof input !== "string") return null;
+  const text = input.trim();
+  if (!text) return null;
+  if (/^<(?!https?:)/i.test(text)) {
+    if (!/<iframe\b/i.test(text)) return null;
+    const iframe = soleIframe(parseHtmlToNodes(text));
+    return iframe ? iframeEmbed(iframe) : null;
+  }
+  const embed = parseVideoEmbedUrl(text);
+  return embed ? { embed, title: null } : null;
+}
+function isBlankInline(node) {
+  return node.type === "text" && !node.value.trim() || node.type === "htmlInline" && node.htmlChildren.length === 0;
+}
+function findBlockVideoEmbed(node) {
+  if (node.type === "htmlBlock") {
+    const iframe = soleIframe(node.htmlChildren);
+    const found = iframe ? iframeEmbed(iframe) : null;
+    return found ? { ...found, form: "iframe" } : null;
+  }
+  if (node.type !== "paragraph") return null;
+  const text = extractPlainText(node).trim();
+  if (text && !/\s/.test(text)) {
+    const bare = parseVideoEmbedUrl(text);
+    if (bare) return { embed: bare, title: null, form: "url" };
+  }
+  const significant = node.children.filter((child) => !isBlankInline(child));
+  if (significant.length !== 1 || significant[0].type !== "link") return null;
+  const link = significant[0];
+  const embed = parseVideoEmbedUrl(link.url);
+  if (!embed) return null;
+  const label = extractPlainText(link).trim();
+  const title = label && !isVideoEmbedUrl(label) && label !== link.url ? label : null;
+  return { embed, title, form: title ? "link" : "url" };
+}
+
+// src/markdown/sanitize.ts
+var SAFE_LINK_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "mailto", "tel"]);
+var SAFE_MEDIA_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "blob"]);
+var NEVER_ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["javascript", "vbscript", "data"]);
+var SAFE_DATA_MEDIA_RE = /^data:(?:image\/(?!svg\+xml)[a-z0-9.+-]+|audio\/[a-z0-9.+-]+|video\/[a-z0-9.+-]+);/i;
+var SAFE_TAGS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "b",
+  "blockquote",
+  "br",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "figcaption",
+  "figure",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "hr",
+  "i",
+  "img",
+  "kbd",
+  "li",
+  "mark",
+  "ol",
+  "p",
+  "pre",
+  "q",
+  "s",
+  "samp",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "audio"
+]);
+var DROP_WITH_CONTENT_TAGS = /* @__PURE__ */ new Set([
+  "base",
+  "button",
+  "embed",
+  "form",
+  "iframe",
+  "input",
+  "link",
+  "meta",
+  "object",
+  "option",
+  "script",
+  "select",
+  "style",
+  "svg",
+  "template",
+  "textarea"
+]);
+var GLOBAL_ATTRS = /* @__PURE__ */ new Set(["class", "id", "title", "role"]);
+var TAG_ATTRS = {
+  a: /* @__PURE__ */ new Set(["href", "target", "rel"]),
+  audio: /* @__PURE__ */ new Set(["src", "controls", "preload", "muted", "loop"]),
+  col: /* @__PURE__ */ new Set(["span", "width"]),
+  colgroup: /* @__PURE__ */ new Set(["span"]),
+  data: /* @__PURE__ */ new Set(["value"]),
+  img: /* @__PURE__ */ new Set(["src", "alt", "width", "height", "loading", "decoding"]),
+  li: /* @__PURE__ */ new Set(["value"]),
+  ol: /* @__PURE__ */ new Set(["start", "type"]),
+  q: /* @__PURE__ */ new Set(["cite"]),
+  source: /* @__PURE__ */ new Set(["src", "type", "media"]),
+  td: /* @__PURE__ */ new Set(["colspan", "rowspan", "align"]),
+  th: /* @__PURE__ */ new Set(["colspan", "rowspan", "align", "scope"]),
+  time: /* @__PURE__ */ new Set(["datetime"]),
+  track: /* @__PURE__ */ new Set(["src", "kind", "label", "srclang", "default"]),
+  video: /* @__PURE__ */ new Set([
+    "src",
+    "poster",
+    "width",
+    "height",
+    "controls",
+    "preload",
+    "muted",
+    "loop",
+    "playsinline"
+  ])
+};
+var SAFE_ATTR_NAME_RE = /^[a-z][a-z0-9:_.-]*$/;
+var SAFE_OL_TYPES = /* @__PURE__ */ new Set(["1", "a", "A", "i", "I"]);
+var SAFE_PRELOAD_VALUES = /* @__PURE__ */ new Set(["none", "metadata", "auto"]);
+var SAFE_TRACK_KINDS = /* @__PURE__ */ new Set(["subtitles", "captions", "descriptions", "chapters", "metadata"]);
+function sanitizeUrl(url, kind = "link", options) {
+  if (typeof url !== "string") return null;
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  const compact = stripUrlSchemeNoise(trimmed);
+  const colon = compact.indexOf(":");
+  const firstPathChar = firstIndexOfAny(compact, ["/", "?", "#"]);
+  const hasScheme = colon >= 0 && (firstPathChar < 0 || colon < firstPathChar);
+  if (!hasScheme) return trimmed;
+  const scheme = compact.slice(0, colon).toLowerCase();
+  if (kind === "media") {
+    if (scheme === "data") return SAFE_DATA_MEDIA_RE.test(compact) ? trimmed : null;
+    return SAFE_MEDIA_SCHEMES.has(scheme) ? trimmed : null;
+  }
+  if (SAFE_LINK_SCHEMES.has(scheme)) return trimmed;
+  if (options?.extraLinkSchemes?.includes(scheme) && !NEVER_ALLOWED_SCHEMES.has(scheme)) {
+    return trimmed;
+  }
+  return null;
+}
+function sanitizeHtmlNodes(nodes) {
+  const out = [];
+  for (const node of nodes) {
+    out.push(...sanitizeHtmlNode(node));
+  }
+  return out;
+}
+function sanitizeHtmlNode(node) {
+  switch (node.type) {
+    case "htmlText":
+      return [node];
+    case "htmlComment":
+      return [];
+    case "htmlElement":
+      return sanitizeHtmlElement(node);
+  }
+}
+function sanitizeHtmlElement(node) {
+  const tag = node.tagName.toLowerCase();
+  if (tag === "iframe") return sanitizeVideoEmbedIframe(node);
+  if (DROP_WITH_CONTENT_TAGS.has(tag)) return [];
+  const children = sanitizeHtmlNodes(node.children);
+  if (!SAFE_TAGS.has(tag)) return children;
+  return [
+    {
+      type: "htmlElement",
+      tagName: tag,
+      attributes: sanitizeAttrs(tag, node.attributes),
+      children,
+      selfClosing: node.selfClosing
+    }
+  ];
+}
+function sanitizeVideoEmbedIframe(node) {
+  const found = videoEmbedFromIframe(node);
+  if (!found) return [];
+  const attributes = videoEmbedIframeAttributes(found.embed, found.title);
+  for (const [rawName, value] of Object.entries(node.attributes)) {
+    const name = rawName.toLowerCase();
+    if ((name === "width" || name === "height") && isNonNegativeInteger(value)) {
+      attributes[name] = value.trim();
+    }
+  }
+  return [{ type: "htmlElement", tagName: "iframe", attributes, children: [], selfClosing: false }];
+}
+function sanitizeAttrs(tag, attrs) {
+  const out = {};
+  for (const [rawName, rawValue] of Object.entries(attrs)) {
+    const name = rawName.toLowerCase();
+    if (!isAllowedAttr(tag, name)) continue;
+    const value = String(rawValue);
+    const safeValue = sanitizeAttrValue(tag, name, value);
+    if (safeValue === null) continue;
+    out[name] = safeValue;
+  }
+  if (tag === "a" && out.target === "_blank") {
+    out.rel = ensureRelTokens(out.rel, ["noopener", "noreferrer"]);
+  }
+  return out;
+}
+function isAllowedAttr(tag, name) {
+  if (!SAFE_ATTR_NAME_RE.test(name)) return false;
+  if (name.startsWith("on")) return false;
+  if (name.startsWith("aria-") || name.startsWith("data-")) return true;
+  if (GLOBAL_ATTRS.has(name)) return true;
+  return TAG_ATTRS[tag]?.has(name) ?? false;
+}
+function sanitizeAttrValue(tag, name, value) {
+  if (name === "href") return sanitizeUrl(value, "link");
+  if (name === "src" || name === "poster") return sanitizeUrl(value, "media");
+  if ((name === "width" || name === "height" || name === "span" || name === "colspan" || name === "rowspan" || name === "value") && !isNonNegativeInteger(value)) {
+    return null;
+  }
+  if (name === "start" && !isInteger(value)) return null;
+  if (name === "type" && tag === "ol" && !SAFE_OL_TYPES.has(value)) return null;
+  if (name === "preload" && !SAFE_PRELOAD_VALUES.has(value)) return null;
+  if (name === "kind" && tag === "track" && !SAFE_TRACK_KINDS.has(value)) return null;
+  if (name === "align" && value !== "left" && value !== "right" && value !== "center") return null;
+  if (name === "target")
+    return value === "_blank" || value === "_self" || value === "_parent" || value === "_top" ? value : null;
+  if (name === "rel") return sanitizeRel(value);
+  return value;
+}
+function sanitizeRel(value) {
+  return relTokens(value).join(" ");
+}
+function ensureRelTokens(value, required) {
+  const tokens = new Set(value ? relTokens(value) : []);
+  for (const token of required) tokens.add(token);
+  return Array.from(tokens).join(" ");
+}
+function relTokens(value) {
+  const tokens = value.split(/\s+/).map((token) => token.trim().toLowerCase()).filter(Boolean).filter((token) => /^[a-z0-9_-]+$/.test(token));
+  return Array.from(new Set(tokens));
+}
+function isInteger(value) {
+  return /^-?\d+$/.test(value.trim());
+}
+function isNonNegativeInteger(value) {
+  return /^\d+$/.test(value.trim());
+}
+function firstIndexOfAny(value, needles) {
+  let result = -1;
+  for (const needle of needles) {
+    const index = value.indexOf(needle);
+    if (index >= 0 && (result < 0 || index < result)) result = index;
+  }
+  return result;
+}
+function stripUrlSchemeNoise(value) {
+  let out = "";
+  for (const char of value) {
+    const code = char.charCodeAt(0);
+    if (code <= 32 || code === 127 || char.trim() === "") continue;
+    out += char;
+  }
+  return out;
+}
+
+// src/markdown/svgIsland.ts
+import { fromHtml as fromHtml2 } from "hast-util-from-html";
+function isSvgIslandLang(lang) {
+  return lang?.trim().toLowerCase() === "svg";
+}
+function isSvgIslandFence(node) {
+  return node.type === "code" && isSvgIslandLang(node.lang);
+}
+function isSvgImageSource(src) {
+  const trimmed = src?.trim();
+  if (!trimmed) return false;
+  if (/^data:image\/svg\+xml[;,]/i.test(trimmed)) return true;
+  return /\.svg$/i.test(trimmed.split(/[?#]/, 1)[0]);
+}
+function svgSourceFromBytes(bytes) {
+  return new TextDecoder("utf-8").decode(bytes).replace(/^\uFEFF/, "");
+}
+function svgSourceFromDataUrl(url) {
+  const match = /^data:image\/svg\+xml((?:;[^,]*)?),([\s\S]*)$/i.exec(url.trim());
+  if (!match) return null;
+  const [, params, payload] = match;
+  try {
+    if (/;base64/i.test(params ?? "")) {
+      const binary = atob(payload.replace(/\s+/g, ""));
+      const bytes = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+      return svgSourceFromBytes(bytes);
+    }
+    return decodeURIComponent(payload);
+  } catch {
+    return null;
+  }
+}
+var SVG_NS = "http://www.w3.org/2000/svg";
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+var ELEMENTS = [
+  "svg",
+  "g",
+  "defs",
+  "symbol",
+  "use",
+  "switch",
+  "title",
+  "desc",
+  "style",
+  "path",
+  "rect",
+  "circle",
+  "ellipse",
+  "line",
+  "polyline",
+  "polygon",
+  "text",
+  "tspan",
+  "textPath",
+  "image",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "pattern",
+  "clipPath",
+  "mask",
+  "marker",
+  "filter",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feDistantLight",
+  "feDropShadow",
+  "feFlood",
+  "feFuncA",
+  "feFuncB",
+  "feFuncG",
+  "feFuncR",
+  "feGaussianBlur",
+  "feImage",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "fePointLight",
+  "feSpecularLighting",
+  "feSpotLight",
+  "feTile",
+  "feTurbulence",
+  "animate",
+  "animateTransform",
+  "animateMotion",
+  "mpath",
+  "set"
+];
+var ELEMENT_BY_LOWER = new Map(ELEMENTS.map((tag) => [tag.toLowerCase(), tag]));
+var ANIMATION_ELEMENTS = /* @__PURE__ */ new Set(["animate", "animateTransform", "animateMotion", "set"]);
+var TEXT_ELEMENTS = /* @__PURE__ */ new Set(["text", "tspan", "textPath", "title", "desc", "style"]);
+var TEXT_ONLY_ELEMENTS = /* @__PURE__ */ new Set(["title", "desc", "style"]);
+var LOCAL_HREF_ELEMENTS = /* @__PURE__ */ new Set([
+  "use",
+  "textPath",
+  "mpath",
+  "feImage",
+  "linearGradient",
+  "radialGradient",
+  "pattern",
+  "filter",
+  "animate",
+  "animateTransform",
+  "animateMotion",
+  "set"
+]);
+var ATTRIBUTES = [
+  // Core
+  "id",
+  "class",
+  "style",
+  "lang",
+  "xml:lang",
+  "xml:space",
+  "role",
+  "aria-label",
+  "aria-hidden",
+  "href",
+  "xlink:href",
+  "version",
+  // Geometry & coordinate systems
+  "x",
+  "y",
+  "x1",
+  "y1",
+  "x2",
+  "y2",
+  "cx",
+  "cy",
+  "r",
+  "rx",
+  "ry",
+  "fx",
+  "fy",
+  "fr",
+  "dx",
+  "dy",
+  "width",
+  "height",
+  "d",
+  "points",
+  "pathLength",
+  "transform",
+  "transform-origin",
+  "viewBox",
+  "preserveAspectRatio",
+  "overflow",
+  "rotate",
+  "textLength",
+  "lengthAdjust",
+  "startOffset",
+  "method",
+  "spacing",
+  "side",
+  "refX",
+  "refY",
+  "markerWidth",
+  "markerHeight",
+  "markerUnits",
+  "orient",
+  "patternUnits",
+  "patternContentUnits",
+  "patternTransform",
+  "gradientUnits",
+  "gradientTransform",
+  "spreadMethod",
+  "offset",
+  "clipPathUnits",
+  "maskUnits",
+  "maskContentUnits",
+  "filterUnits",
+  "primitiveUnits",
+  "requiredExtensions",
+  "systemLanguage",
+  // Presentation
+  "fill",
+  "fill-opacity",
+  "fill-rule",
+  "stroke",
+  "stroke-width",
+  "stroke-opacity",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-miterlimit",
+  "stroke-dasharray",
+  "stroke-dashoffset",
+  "opacity",
+  "color",
+  "display",
+  "visibility",
+  "clip-path",
+  "clip-rule",
+  "mask",
+  "filter",
+  "marker-start",
+  "marker-mid",
+  "marker-end",
+  "stop-color",
+  "stop-opacity",
+  "font-family",
+  "font-size",
+  "font-size-adjust",
+  "font-stretch",
+  "font-style",
+  "font-variant",
+  "font-weight",
+  "letter-spacing",
+  "word-spacing",
+  "text-anchor",
+  "text-decoration",
+  "dominant-baseline",
+  "alignment-baseline",
+  "baseline-shift",
+  "writing-mode",
+  "direction",
+  "unicode-bidi",
+  "shape-rendering",
+  "text-rendering",
+  "image-rendering",
+  "color-interpolation",
+  "color-interpolation-filters",
+  "flood-color",
+  "flood-opacity",
+  "lighting-color",
+  "paint-order",
+  "vector-effect",
+  // Filter primitives
+  "in",
+  "in2",
+  "result",
+  "stdDeviation",
+  "operator",
+  "k1",
+  "k2",
+  "k3",
+  "k4",
+  "mode",
+  "type",
+  "values",
+  "tableValues",
+  "slope",
+  "intercept",
+  "amplitude",
+  "exponent",
+  "kernelMatrix",
+  "order",
+  "divisor",
+  "bias",
+  "targetX",
+  "targetY",
+  "edgeMode",
+  "preserveAlpha",
+  "kernelUnitLength",
+  "surfaceScale",
+  "specularConstant",
+  "specularExponent",
+  "diffuseConstant",
+  "azimuth",
+  "elevation",
+  "pointsAtX",
+  "pointsAtY",
+  "pointsAtZ",
+  "limitingConeAngle",
+  "scale",
+  "xChannelSelector",
+  "yChannelSelector",
+  "baseFrequency",
+  "numOctaves",
+  "seed",
+  "stitchTiles",
+  "radius",
+  "z",
+  // Animation
+  "attributeName",
+  "attributeType",
+  "from",
+  "to",
+  "by",
+  "begin",
+  "dur",
+  "end",
+  "min",
+  "max",
+  "restart",
+  "repeatCount",
+  "repeatDur",
+  "calcMode",
+  "keyTimes",
+  "keySplines",
+  "keyPoints",
+  "additive",
+  "accumulate",
+  "path"
+];
+function attributeKey(name) {
+  return name.toLowerCase().replace(/[-:]/g, "");
+}
+var ATTRIBUTE_BY_KEY = new Map([
+  ...ATTRIBUTES.map((name) => [attributeKey(name), name]),
+  ["classname", "class"]
+]);
+var FREE_TEXT_ATTRIBUTES = /* @__PURE__ */ new Set(["aria-label"]);
+var UNANIMATABLE = /* @__PURE__ */ new Set(["href", "xlink:href", "style"]);
+var RASTER_DATA_URI_RE = /^data:image\/(?:png|jpeg|gif|webp);base64,[A-Za-z0-9+/=\s]*$/i;
+var LOCAL_REF_RE = /^#[^\s"'<>()\\]+$/;
+var URL_FUNCTION_RE = /url\s*\(/gi;
+var LOCAL_URL_RE = /^url\(\s*(['"]?)#[^\s"'<>()\\]+\1\s*\)/i;
+var FETCHING_FUNCTION_RE = /(?:^|[^a-z0-9_-])(?:-webkit-image-set|image-set|image|cross-fade|src|element|paint)\s*\(/i;
+var FORBIDDEN_CSS_RE = /@import|@font-face|@namespace|@document|-moz-binding|behavior\s*:|expression\s*\(|javascript:/i;
+var REMOTE_REF_RE = /[a-z][a-z0-9+.-]*:\/\//i;
+var XML_INVALID_RE = /[\u0000-\u0008\u000B\u000C\u000E-\u001F￾￿]/g;
+var LONE_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+var SAFE_COLOR_RE = /^(?:#[0-9a-f]{3,8}|(?:rgb|rgba|hsl|hsla)\([\d\s.,%a-z/+-]*\)|[a-z]{3,20})$/i;
+var ISLAND_TREES = /* @__PURE__ */ new WeakMap();
+var IslandLimitError = class extends Error {
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+  }
+};
+var DiagnosticLog = class {
+  constructor() {
+    this.counts = /* @__PURE__ */ new Map();
+  }
+  add(kind, name) {
+    const key = `${kind}:${name}`;
+    const existing = this.counts.get(key);
+    if (existing) existing.count += 1;
+    else this.counts.set(key, { kind, name, count: 1 });
+  }
+  list() {
+    return [...this.counts.values()];
+  }
+};
+function isSafeCssValue(value) {
+  if (value.includes("\\")) return false;
+  if (FORBIDDEN_CSS_RE.test(value) || REMOTE_REF_RE.test(value)) return false;
+  if (FETCHING_FUNCTION_RE.test(value)) return false;
+  URL_FUNCTION_RE.lastIndex = 0;
+  for (let match = URL_FUNCTION_RE.exec(value); match; match = URL_FUNCTION_RE.exec(value)) {
+    if (!LOCAL_URL_RE.test(value.slice(match.index))) return false;
+  }
+  return true;
+}
+function cleanText(value) {
+  return value.replace(LONE_SURROGATE_RE, "\uFFFD").replace(XML_INVALID_RE, "");
+}
+function splitCssStatements(css) {
+  const statements = [];
+  let depth = 0;
+  let quote = null;
+  let start = 0;
+  for (let i = 0; i < css.length; i++) {
+    const ch = css[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") quote = ch;
+    else if (ch === "{") depth += 1;
+    else if (ch === "}") {
+      depth -= 1;
+      if (depth <= 0) {
+        statements.push(css.slice(start, i + 1));
+        start = i + 1;
+        depth = 0;
+      }
+    } else if (ch === ";" && depth === 0) {
+      statements.push(css.slice(start, i + 1));
+      start = i + 1;
+    }
+  }
+  if (depth === 0 && quote === null && css.slice(start).trim()) statements.push(css.slice(start));
+  return statements.map((statement) => statement.trim()).filter(Boolean);
+}
+var ANIMATION_DECLARATION_RE = /(?:^|[;{\s])(?:animation|transition)[a-z-]*\s*:[^;{}]*;?/gi;
+function stripCssMotion(css) {
+  return css.replace(ANIMATION_DECLARATION_RE, (match) => /^[;{\s]/.test(match) ? match[0] : "");
+}
+function sanitizeCss(css, isStatic, log) {
+  const uncommented = cleanText(css).replace(/\/\*[\s\S]*?(?:\*\/|$)/g, " ");
+  const kept = [];
+  for (const statement of splitCssStatements(uncommented)) {
+    if (!isSafeCssValue(statement)) {
+      log.add("style", "style rule");
+      continue;
+    }
+    if (isStatic && /^@(?:-[a-z]+-)?keyframes\b/i.test(statement)) continue;
+    kept.push(isStatic ? stripCssMotion(statement) : statement);
+  }
+  return kept.join("\n");
+}
+function propertyText(name, value) {
+  if (value === null || value === void 0 || value === false) return null;
+  if (value === true) return "";
+  if (Array.isArray(value)) return value.join(name === "systemLanguage" ? ", " : " ");
+  if (typeof value === "number" || typeof value === "string") return String(value);
+  return null;
+}
+function sanitizeAttribute(tag, name, value, isStatic, log) {
+  const text = cleanText(value);
+  if (name === "href" || name === "xlink:href") {
+    const ref = text.trim();
+    if (tag === "image" && RASTER_DATA_URI_RE.test(ref)) return ref;
+    if (LOCAL_HREF_ELEMENTS.has(tag) && LOCAL_REF_RE.test(ref)) return ref;
+    log.add("attribute", name);
+    return null;
+  }
+  if (name === "style") {
+    const css = sanitizeCss(text, isStatic, log);
+    return css.trim() ? css : null;
+  }
+  if (name === "attributeName") {
+    const target = ATTRIBUTE_BY_KEY.get(attributeKey(text.trim()));
+    if (!target || UNANIMATABLE.has(target)) {
+      log.add("attribute", "attributeName");
+      return null;
+    }
+    return target;
+  }
+  if (FREE_TEXT_ATTRIBUTES.has(name)) return text;
+  if (!isSafeCssValue(text)) {
+    log.add("attribute", name);
+    return null;
+  }
+  return text;
+}
+function stripProlog(source) {
+  let rest = source.replace(/^\uFEFF/, "");
+  for (let i = 0; i < 16; i++) {
+    rest = rest.trimStart();
+    let end = -1;
+    if (rest.startsWith("<?")) {
+      end = rest.indexOf("?>");
+      if (end >= 0) end += 2;
+    } else if (rest.startsWith("<!--")) {
+      end = rest.indexOf("-->", 4);
+      if (end >= 0) end += 3;
+    } else if (/^<!doctype/i.test(rest)) {
+      const gt = rest.indexOf(">");
+      const bracket = rest.indexOf("[");
+      if (bracket >= 0 && (gt < 0 || bracket < gt)) {
+        const close = rest.indexOf("]", bracket);
+        const afterClose = close >= 0 ? rest.indexOf(">", close) : -1;
+        end = afterClose >= 0 ? afterClose + 1 : -1;
+      } else {
+        end = gt >= 0 ? gt + 1 : -1;
+      }
+    } else {
+      break;
+    }
+    if (end < 0) break;
+    rest = rest.slice(end);
+  }
+  return rest;
+}
+function textContent(node) {
+  if (node.type === "text") return node.value ?? "";
+  return (node.children ?? []).map(textContent).join("");
+}
+function getAttr(element, name) {
+  return element.attrs.find(([attr]) => attr === name)?.[1];
+}
+function setAttr(element, name, value) {
+  const at = element.attrs.findIndex(([attr]) => attr === name);
+  if (at >= 0) element.attrs[at] = [name, value];
+  else element.attrs.push([name, value]);
+}
+function sanitizeElement(node, canonical, depth, state) {
+  if (depth > SVG_ISLAND_LIMITS.maxDepth) {
+    throw new IslandLimitError("too-deep", "The SVG is nested too deeply to render.");
+  }
+  state.elements += 1;
+  if (state.elements > SVG_ISLAND_LIMITS.maxElements) {
+    throw new IslandLimitError("too-large", "The SVG has too many elements to render.");
+  }
+  const element = { tag: canonical, attrs: [], children: [] };
+  for (const [prop, raw] of Object.entries(node.properties ?? {})) {
+    if (/^on/i.test(prop)) {
+      state.log.add("attribute", prop.toLowerCase());
+      continue;
+    }
+    const name = ATTRIBUTE_BY_KEY.get(attributeKey(prop));
+    if (!name || getAttr(element, name) !== void 0) continue;
+    const text = propertyText(prop, raw);
+    if (text === null) continue;
+    const value = sanitizeAttribute(canonical, name, text, state.isStatic, state.log);
+    if (value !== null) element.attrs.push([name, value]);
+  }
+  if (TEXT_ONLY_ELEMENTS.has(canonical)) {
+    const text = textContent(node);
+    const content = canonical === "style" ? sanitizeCss(text, state.isStatic, state.log) : text;
+    if (content.trim()) element.children.push(cleanText(content));
+    return element;
+  }
+  const freezes = [];
+  element.children = sanitizeChildren(node.children ?? [], canonical, depth, state, freezes);
+  for (const freeze of freezes) {
+    const value = sanitizeAttribute(canonical, freeze.name, freeze.value, true, state.log);
+    if (value !== null) setAttr(element, freeze.name, value);
+  }
+  return element;
+}
+function sanitizeChildren(children, parentTag, depth, state, freezes) {
+  const out = [];
+  for (const child of children) {
+    if (child.type === "text") {
+      if (TEXT_ELEMENTS.has(parentTag) && child.value) out.push(cleanText(child.value));
+      continue;
+    }
+    if (child.type !== "element" || !child.tagName) continue;
+    if (child.tagName.toLowerCase() === "a") {
+      out.push(...sanitizeChildren(child.children ?? [], parentTag, depth + 1, state, []));
+      continue;
+    }
+    const canonical = ELEMENT_BY_LOWER.get(child.tagName.toLowerCase());
+    if (!canonical) {
+      state.log.add("element", child.tagName);
+      continue;
+    }
+    if (state.isStatic && ANIMATION_ELEMENTS.has(canonical)) {
+      const freeze = frozenEndValue(child, canonical);
+      if (freeze) freezes.push(freeze);
+      continue;
+    }
+    out.push(sanitizeElement(child, canonical, depth + 1, state));
+  }
+  return out;
+}
+function frozenEndValue(node, tag) {
+  const props = node.properties ?? {};
+  if (tag !== "animate" && tag !== "set") return null;
+  if (propertyText("fill", props.fill)?.trim() !== "freeze") return null;
+  if (props.href !== void 0 || props.xLinkHref !== void 0) return null;
+  const targetName = propertyText("attributeName", props.attributeName);
+  const name = targetName ? ATTRIBUTE_BY_KEY.get(attributeKey(targetName.trim())) : void 0;
+  if (!name || UNANIMATABLE.has(name)) return null;
+  let value = propertyText("to", props.to);
+  if (value === null && tag === "animate") {
+    const values = propertyText("values", props.values)?.split(";").map((part) => part.trim()).filter(Boolean);
+    value = values && values.length > 0 ? values[values.length - 1] : null;
+  }
+  return value === null ? null : { name, value };
+}
+function checkUseExpansion(root) {
+  const byId = /* @__PURE__ */ new Map();
+  const index = (element) => {
+    const id = getAttr(element, "id");
+    if (id && !byId.has(id)) byId.set(id, element);
+    for (const child of element.children) if (typeof child !== "string") index(child);
+  };
+  index(root);
+  const limit = SVG_ISLAND_LIMITS.maxExpandedElements;
+  const sizes = /* @__PURE__ */ new Map();
+  const visiting = /* @__PURE__ */ new Set();
+  const expandedSize = (element) => {
+    const known = sizes.get(element);
+    if (known !== void 0) return known;
+    if (visiting.has(element)) {
+      throw new IslandLimitError("too-large", "The SVG has a circular <use> reference.");
+    }
+    visiting.add(element);
+    let total = 1;
+    for (const child of element.children) {
+      if (typeof child !== "string") total += expandedSize(child);
+    }
+    if (element.tag === "use") {
+      const ref = getAttr(element, "href") ?? getAttr(element, "xlink:href");
+      const target = ref ? byId.get(ref.slice(1)) : void 0;
+      if (target) total += expandedSize(target);
+    }
+    visiting.delete(element);
+    if (total > limit) {
+      throw new IslandLimitError("too-large", "The SVG expands to too many shapes to render.");
+    }
+    sizes.set(element, total);
+    return total;
+  };
+  expandedSize(root);
+}
+var PX_PER_UNIT = {
+  "": 1,
+  px: 1,
+  pt: 96 / 72,
+  pc: 16,
+  in: 96,
+  cm: 96 / 2.54,
+  mm: 96 / 25.4
+};
+var LENGTH_RE = /^\s*\+?(\d*\.?\d+(?:e[+-]?\d+)?)\s*(px|pt|pc|in|cm|mm)?\s*$/i;
+function lengthPx(value) {
+  const match = value ? LENGTH_RE.exec(value) : null;
+  if (!match) return void 0;
+  const px = Number(match[1]) * PX_PER_UNIT[(match[2] ?? "").toLowerCase()];
+  return Number.isFinite(px) && px > 0 ? px : void 0;
+}
+function parseViewBox(value) {
+  const parts = value?.trim().split(/[\s,]+/).map(Number);
+  if (!parts || parts.length !== 4 || !parts.every(Number.isFinite)) return void 0;
+  const [, , width, height] = parts;
+  return width > 0 && height > 0 ? { width, height } : void 0;
+}
+function roundSize(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function sizeRoot(root) {
+  const viewBox = parseViewBox(getAttr(root, "viewBox"));
+  let width = lengthPx(getAttr(root, "width"));
+  let height = lengthPx(getAttr(root, "height"));
+  if (!width || !height) {
+    if (viewBox) {
+      if (width) height = width * viewBox.height / viewBox.width;
+      else if (height) width = height * viewBox.width / viewBox.height;
+      else ({ width, height } = viewBox);
+    } else {
+      width ?? (width = 300);
+      height ?? (height = 150);
+    }
+  }
+  width = roundSize(width);
+  height = roundSize(height);
+  setAttr(root, "width", String(width));
+  setAttr(root, "height", String(height));
+  if (!viewBox) setAttr(root, "viewBox", `0 0 ${width} ${height}`);
+  return { width, height };
+}
+function islandTitle(root) {
+  const label = getAttr(root, "aria-label");
+  const titleElement = root.children.find(
+    (child) => typeof child !== "string" && child.tag === "title"
+  );
+  const raw = label ?? (titleElement?.children.join("") || void 0);
+  const title = raw?.replace(/\s+/g, " ").trim().slice(0, 200);
+  return title || void 0;
+}
+function escapeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(value) {
+  return escapeText(value).replace(/"/g, "&quot;").replace(/\t/g, "&#9;").replace(/\n/g, "&#10;").replace(/\r/g, "&#13;");
+}
+function usesXlink(element) {
+  if (element.attrs.some(([name]) => name.startsWith("xlink:"))) return true;
+  return element.children.some((child) => typeof child !== "string" && usesXlink(child));
+}
+function serializeElement(element, options, root) {
+  const recolor = (value) => options.replaceCurrentColor && options.color ? value.replace(/currentcolor/gi, options.color) : value;
+  let attrs = "";
+  if (root) {
+    attrs += ` xmlns="${SVG_NS}"`;
+    if (usesXlink(element)) attrs += ` xmlns:xlink="${XLINK_NS}"`;
+    if (options.color && getAttr(element, "color") === void 0) {
+      attrs += ` color="${escapeAttr(options.color)}"`;
+    }
+  }
+  for (const [name, value] of element.attrs) attrs += ` ${name}="${escapeAttr(recolor(value))}"`;
+  if (element.children.length === 0) return `<${element.tag}${attrs}/>`;
+  const body = element.children.map(
+    (child) => typeof child === "string" ? escapeText(element.tag === "style" ? recolor(child) : child) : serializeElement(child, options, false)
+  ).join("");
+  return `<${element.tag}${attrs}>${body}</${element.tag}>`;
+}
+function utf8Length(value) {
+  let bytes = 0;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 128) bytes += 1;
+    else if (code < 2048) bytes += 2;
+    else if (code >= 55296 && code < 56320 && i + 1 < value.length) {
+      bytes += 4;
+      i += 1;
+    } else bytes += 3;
+  }
+  return bytes;
+}
+function failure(reason, message) {
+  return Object.freeze({ ok: false, reason, message });
+}
+function parseUncached(source, isStatic) {
+  if (!source.trim()) return failure("empty", "The SVG fence is empty.");
+  const max = SVG_ISLAND_LIMITS.maxSourceBytes;
+  if (source.length > max || utf8Length(source) > max) {
+    return failure("too-large", "The SVG is too large to render.");
+  }
+  let tree;
+  try {
+    tree = fromHtml2(stripProlog(source), { fragment: true });
+  } catch (err) {
+    return err instanceof RangeError ? failure("too-deep", "The SVG is nested too deeply to render.") : failure("parse", "The SVG could not be read.");
+  }
+  let rootNode;
+  for (const child of tree.children ?? []) {
+    if (child.type === "comment" || child.type === "doctype") continue;
+    if (child.type === "text" && !(child.value ?? "").trim()) continue;
+    if (child.type === "element" && child.tagName === "svg" && !rootNode) {
+      rootNode = child;
+      continue;
+    }
+    return failure("not-svg", "An SVG fence must hold one <svg> element and nothing else.");
+  }
+  if (!rootNode) {
+    return failure("not-svg", "An SVG fence must hold one <svg> element and nothing else.");
+  }
+  const state = { isStatic, log: new DiagnosticLog(), elements: 0 };
+  let root;
+  try {
+    root = sanitizeElement(rootNode, "svg", 0, state);
+    checkUseExpansion(root);
+  } catch (err) {
+    if (err instanceof IslandLimitError) return failure(err.reason, err.message);
+    if (err instanceof RangeError) {
+      return failure("too-deep", "The SVG is nested too deeply to render.");
+    }
+    throw err;
+  }
+  const { width, height } = sizeRoot(root);
+  const title = islandTitle(root);
+  const island = Object.freeze({
+    markup: serializeElement(root, {}, true),
+    width,
+    height,
+    aspectRatio: width / height,
+    ...title ? { title } : {}
+  });
+  ISLAND_TREES.set(island, root);
+  return Object.freeze({
+    ok: true,
+    island,
+    diagnostics: Object.freeze(state.log.list())
+  });
+}
+var RESULT_CACHE = /* @__PURE__ */ new Map();
+var RESULT_CACHE_LIMIT = 48;
+var CACHEABLE_SOURCE_LENGTH = 128 * 1024;
+function parseSvgIsland(source, options = {}) {
+  if (typeof source !== "string") return failure("empty", "The SVG fence is empty.");
+  const isStatic = options.static === true;
+  if (source.length > CACHEABLE_SOURCE_LENGTH) return parseUncached(source, isStatic);
+  const key = (isStatic ? "s:" : "a:") + source;
+  const cached = RESULT_CACHE.get(key);
+  if (cached) {
+    RESULT_CACHE.delete(key);
+    RESULT_CACHE.set(key, cached);
+    return cached;
+  }
+  const result = parseUncached(source, isStatic);
+  RESULT_CACHE.set(key, result);
+  if (RESULT_CACHE.size > RESULT_CACHE_LIMIT) {
+    const oldest = RESULT_CACHE.keys().next().value;
+    if (oldest !== void 0) RESULT_CACHE.delete(oldest);
+  }
+  return result;
+}
+function svgIslandMarkup(island, options = {}) {
+  const color = options.color?.trim();
+  const tree = ISLAND_TREES.get(island);
+  if (!tree || !color || !SAFE_COLOR_RE.test(color)) return island.markup;
+  return serializeElement(
+    tree,
+    { color, replaceCurrentColor: options.replaceCurrentColor === true },
+    true
+  );
+}
+var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function base64(bytes) {
+  const parts = [];
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = bytes[i + 1];
+    const c = bytes[i + 2];
+    const n = a << 16 | (b ?? 0) << 8 | (c ?? 0);
+    parts.push(
+      BASE64[n >> 18 & 63] + BASE64[n >> 12 & 63] + (b === void 0 ? "=" : BASE64[n >> 6 & 63]) + (c === void 0 ? "=" : BASE64[n & 63])
+    );
+  }
+  return parts.join("");
+}
+var DATA_URL_CACHE = /* @__PURE__ */ new WeakMap();
+function svgIslandDataUrl(island, options = {}) {
+  const key = `${options.color ?? ""}|${options.replaceCurrentColor ? 1 : 0}`;
+  let perIsland = DATA_URL_CACHE.get(island);
+  const cached = perIsland?.get(key);
+  if (cached) return cached;
+  const url = `data:image/svg+xml;base64,${base64(new TextEncoder().encode(svgIslandMarkup(island, options)))}`;
+  if (!perIsland) {
+    perIsland = /* @__PURE__ */ new Map();
+    DATA_URL_CACHE.set(island, perIsland);
+  }
+  if (perIsland.size < 8) perIsland.set(key, url);
+  return url;
+}
+
+export {
+  mediaKindForUrl,
+  parseHtmlToNodes,
+  stringifyHtmlNodes,
+  getChildren,
+  walkMarkdownTree,
+  findNodesByType,
+  extractPlainText,
+  countNodes,
+  parseFrontmatter,
+  formatBlockScalar,
+  splitFrontmatterBlock,
+  formatFrontmatterValue,
+  formatFrontmatterYaml,
+  setFrontmatterValues,
+  createDocument,
+  inferDocumentTitle,
+  readFrontmatterThemeId,
+  plainTextFromInlineHtml,
+  KNOWN_BLOCK_META_KEYS,
+  BLOCK_META_KEY_DESCRIPTORS,
+  coerceAnnotationValues,
+  parseNumber,
+  parseTimeSeconds,
+  VIDEO_EMBED_PROVIDERS,
+  parseVideoStartTime,
+  parseVideoEmbedUrl,
+  isVideoEmbedUrl,
+  VIDEO_EMBED_IFRAME_ALLOW,
+  videoEmbedIframeAttributes,
+  videoEmbedFromIframe,
+  parseVideoEmbedInput,
+  findBlockVideoEmbed,
+  sanitizeUrl,
+  sanitizeHtmlNodes,
+  isSvgIslandLang,
+  isSvgIslandFence,
+  isSvgImageSource,
+  svgSourceFromBytes,
+  svgSourceFromDataUrl,
+  parseSvgIsland,
+  svgIslandMarkup,
+  svgIslandDataUrl
+};